Open Project Attachments Through One Guarded Helper

The Edit Project Info view launched attachments directly, without the
checks the project page has. Both now call
desktop_open_project_attachment, which checks that the file is inside
the auxiliary directory, asks for confirmation where needed and then
opens it.

The auxiliary root was built through encode_path, which returns code
page bytes on Windows, while boost::filesystem reads a narrow string as
UTF-8. With a non-ASCII temporary directory the root never matched and
no attachment opened. It is now built from the UTF-8 path directly.

The list of program extensions could not be kept complete and let
unknown types open without a prompt. It is replaced by
is_safe_to_open_file_name, a list of plain document, image, model and
video types that open directly. Everything else asks first.

resources/web/model/model.js

@@ -214,9 +214,9 @@ function ShowModelInfo( pModel )
 	
 	SendWXDebugInfo("Model Name:  "+sModelName);
 	
-	$('#ModelName').html(sModelName);
+	$('#ModelName').text(sModelName);
 	$('#ModelName').attr('title',sModelName);
-    $('#ModelAuthorName').html(sModelAuthor);
+    $('#ModelAuthorName').text(sModelAuthor);
 	
 	switch(UploadType)
 	{
@@ -268,7 +268,7 @@ function ShowModelInfo( pModel )
 			break;
 	}
 	
-	$('#Model_Desc').html( html_decode(sModelDesc) );
+	$('#Model_Desc').empty().append( SanitizeDescHtml( html_decode(sModelDesc) ) );
 			
 	let ModelPreviewList=pModel.preview_img;				
     let TotalPreview=ModelPreviewList.length;
@@ -281,16 +281,15 @@ function ShowModelInfo( pModel )
 	
     if(TotalPreview>0)
 	{
-		let htmlPreview='';
+		$('#ModelPreviewList').empty();
 		for(let pn=0;pn<TotalPreview;pn++)			
 		{	
 			//let FTmpPath=decodeURIComponent(ModelPreviewList[pn]);
 			let FTmpPath=ModelPreviewList[pn]['filepath'];
 			
-			htmlPreview+='<div class="swiper-slide"><img class="Model_PrevImg" src="'+FTmpPath+'" /></div>';
+			$('#ModelPreviewList').append( $('<div class="swiper-slide"></div>').append( $('<img class="Model_PrevImg" />').attr('src',FTmpPath) ) );
 		}
 			
-	    $('#ModelPreviewList').html(htmlPreview);
 		$('#Model_Preview_Image').viewer({
 			title: false,
 		    fullsreen: false,
@@ -410,7 +409,8 @@ function ConstructFileHtml( ID, pItem )
 {
 	let fTotal=pItem.length;
 	
-	let strHtml='';
+	let pBoard=$('#'+ID+'  .FileListBoard');
+	pBoard.empty();
 	for( let f=0;f<fTotal;f++ )
 	{
 		let pOne=pItem[f];
@@ -443,39 +443,139 @@ function ConstructFileHtml( ID, pItem )
 			ImgPath='img/default.png';			
 		}		
 			
-		//Add html
+		//Add html. File names come from the 3MF, so build the nodes rather than concatenating markup.
+		let pIconImg=$('<img />').attr('src',ImgPath);
+		let pMenu=$('<div class="FileMenu"><img src="img/s.svg" /></div>');
 		if( strClass!='ImageIcon' )
 		{
-		strHtml+='<div class="FileItem">'+
-				 '	<div class="'+strClass+'"><img src="'+ImgPath+'" /></div>'+
-				 '	<div class="FileText">'+
-			     '		<div class="FileName">'+tName+'</div>'+
-				 '	</div>'+
-				 '	<div class="FileMenu" onClick="OnClickOpenFile(\''+tPath+'\')"><img src="img/s.svg" /></div>'+
-				 '</div>';
+			pMenu.on('click', function(){ OnClickOpenFile(tPath); });
 		}
 		else
 		{
 			ImgID++;
 			let TmpImgID="AF"+ImgID;
 			
-		strHtml+='<div class="FileItem">'+
-				 '	<div class="'+strClass+'"><img id="'+TmpImgID+'" src="'+ImgPath+'" /></div>'+
-				 '	<div class="FileText">'+
-			     '		<div class="FileName">'+tName+'</div>'+
-				 '	</div>'+
-				 '	<div class="FileMenu" onClick="OnClickOpenImage(\''+TmpImgID+'\')"><img src="img/s.svg" /></div>'+
-				 '</div>';			
+			pIconImg.attr('id',TmpImgID);
+			pMenu.on('click', function(){ OnClickOpenImage(TmpImgID); });
 		}
+		
+		let pFileItem=$('<div class="FileItem"></div>');
+		pFileItem.append( $('<div></div>').addClass(strClass).append(pIconImg) );
+		pFileItem.append( $('<div class="FileText"></div>').append( $('<div class="FileName"></div>').text(tName).attr('title',tName) ) );
+		pFileItem.append( pMenu );
+		pBoard.append( pFileItem );
 	}
 	
-	$('#'+ID+'  .FileListBoard').html(strHtml);
-	
     if( fTotal>0 )
 		$('#'+ID).show();
 }
 
 
+// Descriptions are untrusted 3MF metadata that may carry rich-text HTML (e.g. from MakerWorld).
+// Rebuild them from an inert parse, keeping only plain formatting tags and http(s) links and images.
+var DescAllowedTags=['P','BR','B','STRONG','I','EM','U','S','STRIKE','DEL','INS','SUB','SUP','SMALL','MARK',
+	'Q','ABBR','KBD','WBR','H1','H2','H3','H4','H5','H6','UL','OL','LI','DL','DT','DD','BLOCKQUOTE','PRE','CODE',
+	'HR','SPAN','DIV','FIGURE','FIGCAPTION','TABLE','CAPTION','THEAD','TBODY','TFOOT','TR','TH','TD','A','IMG'];
+// Plain attributes kept per tag; the numeric ones must be plain non-negative integers.
+var DescAllowedAttrs={'IMG':['alt','title','width','height'],'TD':['colspan','rowspan'],'TH':['colspan','rowspan'],'OL':['start']};
+var DescNumericAttrs=['width','height','colspan','rowspan','start'];
+// Dropped together with their content; any other unknown tag is unwrapped to its children.
+var DescDroppedTags=['SCRIPT','STYLE','TEMPLATE','NOSCRIPT','TEXTAREA','TITLE','IFRAME','FRAME','OBJECT','EMBED','SVG','MATH'];
+
+function IsHttpUrl( strUrl )
+{
+	// The scheme must be written as is, so nothing the URL parser would strip can precede or split it.
+	if( typeof strUrl!='string' || !/^https?:/i.test(strUrl) )
+		return false;
+	try
+	{
+		let sProtocol=new URL(strUrl).protocol;
+		return sProtocol=='http:' || sProtocol=='https:';
+	}
+	catch(e)
+	{
+		return false;
+	}
+}
+
+// Images load as soon as the page opens, so only https sources are kept: no plain-http requests to the local network.
+function IsHttpsUrl( strUrl )
+{
+	return IsHttpUrl(strUrl) && new URL(strUrl).protocol=='https:';
+}
+
+// Embedded YouTube players become a plain link to the video.
+function GetYouTubeEmbedUrl( pNode )
+{
+	let sSrc=pNode.getAttribute('src');
+	if( !IsHttpUrl(sSrc) )
+		return null;
+	let pUrl=new URL(sSrc);
+	return ( pUrl.origin=='https://www.youtube.com' && pUrl.pathname.indexOf('/embed/')==0 ) ? pUrl.href : null;
+}
+
+function CopyDescNodes( pSrc, pDst )
+{
+	for( let pNode=pSrc.firstChild;pNode!=null;pNode=pNode.nextSibling )
+	{
+		if( pNode.nodeType==Node.TEXT_NODE )
+		{
+			pDst.appendChild( document.createTextNode(pNode.nodeValue) );
+			continue;
+		}
+		if( pNode.nodeType!=Node.ELEMENT_NODE )
+			continue;
+		
+		let sTag=pNode.nodeName.toUpperCase();
+		if( sTag=='IFRAME' )
+		{
+			let sVideoUrl=GetYouTubeEmbedUrl(pNode);
+			if( sVideoUrl!=null )
+			{
+				let pLink=document.createElement('A');
+				pLink.setAttribute('href',sVideoUrl);
+				pLink.textContent=sVideoUrl;
+				pDst.appendChild(pLink);
+			}
+			continue;
+		}
+		if( $.inArray(sTag,DescDroppedTags)>=0 )
+			continue;
+		if( $.inArray(sTag,DescAllowedTags)<0 )
+		{
+			CopyDescNodes(pNode,pDst);
+			continue;
+		}
+		
+		let pElem=document.createElement(sTag);
+		if( sTag=='A' && IsHttpUrl(pNode.getAttribute('href')) )
+			pElem.setAttribute('href',pNode.getAttribute('href'));
+		else if( sTag=='IMG' )
+		{
+			if( !IsHttpsUrl(pNode.getAttribute('src')) )
+				continue;
+			pElem.setAttribute('src',pNode.getAttribute('src'));
+		}
+		$.each( DescAllowedAttrs[sTag]||[], function(i,sAttr){
+			let sValue=pNode.getAttribute(sAttr);
+			if( sValue!=null && ( $.inArray(sAttr,DescNumericAttrs)<0 || /^\d+$/.test(sValue) ) )
+				pElem.setAttribute(sAttr,sValue);
+		});
+		CopyDescNodes(pNode,pElem);
+		pDst.appendChild(pElem);
+	}
+}
+
+function SanitizeDescHtml( strHtml )
+{
+	let pFragment=document.createDocumentFragment();
+	// A DOMParser document is inert: it runs no scripts and loads no resources.
+	let pDoc=new DOMParser().parseFromString(strHtml,'text/html');
+	if( pDoc && pDoc.body )
+		CopyDescNodes(pDoc.body,pFragment);
+	return pFragment;
+}
+
 function ShowProfilelInfo( pProfile )
 {
 	//==========Profile Info==========
@@ -483,10 +583,10 @@ function ShowProfilelInfo( pProfile )
 	let sProfileAuthor=decodeURIComponent(pProfile.author);
 	let sProfileDesc=decodeURIComponent(pProfile.description);
 	
-	$('#ProfileName').html(sProfileName);
-    $('#ProfileAuthor').html(sProfileAuthor);
+	$('#ProfileName').text(sProfileName);
+    $('#ProfileAuthor').text(sProfileAuthor);
 		
-	$('#Profile_Desc').html( html_decode(sProfileDesc) );
+	$('#Profile_Desc').empty().append( SanitizeDescHtml( html_decode(sProfileDesc) ) );
 			
 	let ProfilePreviewList=pProfile.preview_img;				
     let TotalPreview=ProfilePreviewList.length;
@@ -499,15 +599,14 @@ function ShowProfilelInfo( pProfile )
 	
     if(TotalPreview>0)
 	{
-		let htmlPreview='';
+		$('#ProfilePreviewList').empty();
 		for(let pn=0;pn<TotalPreview;pn++)			
 		{	
 			let FTmpPath=ProfilePreviewList[pn]['filepath'];
 			
-			htmlPreview+='<div class="swiper-slide"><img class="Model_PrevImg" src="'+FTmpPath+'" /></div>';
+			$('#ProfilePreviewList').append( $('<div class="swiper-slide"></div>').append( $('<img class="Model_PrevImg" />').attr('src',FTmpPath) ) );
 		}
 			
-		$('#ProfilePreviewList').html(htmlPreview);
 		$('#Profile_Preview_Image').viewer({
 			title: false,
 		    fullsreen: false,

src/OrcaSlicer.cpp

@@ -642,6 +642,162 @@ static void load_default_gcodes_to_config(DynamicPrintConfig& config, Preset::Ty
     }
 }
 
+static int load_assemble_plate_list(std::string config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list)
+{
+    int ret = 0;
+    boost::filesystem::path directory_path(config_file);
+
+    BOOST_LOG_TRIVIAL(info) << boost::format("%1% enter, file %2%")%__FUNCTION__ % config_file;
+    if (!fs::exists(directory_path)) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("directory %1% not exist.")%config_file;
+        return CLI_FILE_NOTFOUND;
+    }
+
+    try {
+        json root_json;
+        boost::nowide::ifstream ifs(config_file);
+        ifs >> root_json;
+        ifs.close();
+
+        int plate_count = root_json[JSON_ASSEMPLE_PLATES].size();
+        if ((plate_count <= 0) || (plate_count > MAX_PLATE_COUNT)) {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid plate count %1%")%plate_count;
+            return CLI_CONFIG_FILE_ERROR;
+        }
+        assemble_plate_info_list.resize(plate_count);
+
+        for (int plate_index = 0; plate_index < plate_count; plate_index++)
+        {
+            assemble_plate_info_t &assemble_plate = assemble_plate_info_list[plate_index];
+            const json& plate_json = root_json[JSON_ASSEMPLE_PLATES][plate_index];
+            assemble_plate.plate_name = plate_json[JSON_ASSEMPLE_PLATE_NAME];
+            assemble_plate.need_arrange = plate_json[JSON_ASSEMPLE_PLATE_NEED_ARRANGE];
+
+            if (plate_json.contains(JSON_ASSEMPLE_PLATE_PARAMS)) {
+                assemble_plate.plate_params = plate_json[JSON_ASSEMPLE_PLATE_PARAMS].get<std::map<std::string, std::string>>();
+                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
+            }
+
+            int object_count = plate_json[JSON_ASSEMPLE_OBJECTS].size();
+            if (object_count <= 0) {
+                BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid object count %1% in plate %2%")%object_count %(plate_index+1);
+                return CLI_CONFIG_FILE_ERROR;
+            }
+
+            assemble_plate.assemble_obj_list.resize(object_count);
+            for (int object_index = 0; object_index < object_count; object_index++)
+            {
+                assemble_object_info_t& assemble_object = assemble_plate.assemble_obj_list[object_index];
+                const json& object_json = plate_json[JSON_ASSEMPLE_OBJECTS][object_index];
+
+                assemble_object.path = object_json[JSON_ASSEMPLE_OBJECT_PATH];
+                assemble_object.count = object_json[JSON_ASSEMPLE_OBJECT_COUNT];
+
+                if (assemble_object.count <= 0) {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": invalid object clone count %1% in plate %2% Object %3%") % assemble_object.count % (plate_index + 1) % assemble_object.path;
+                    return CLI_CONFIG_FILE_ERROR;
+                }
+
+                assemble_object.filaments = object_json.at(JSON_ASSEMPLE_OBJECT_FILAMENTS).get<std::vector<int>>();
+                if ((assemble_object.filaments.size() > 0) && (assemble_object.filaments.size() != assemble_object.count) && (assemble_object.filaments.size() != 1))
+                {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.filaments.size() % assemble_object.count;
+                    return CLI_CONFIG_FILE_ERROR;
+                }
+
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX)) {
+                    assemble_object.assemble_index = object_json[JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX].get<std::vector<int>>();
+                    if ((assemble_object.assemble_index.size() > 0) && (assemble_object.assemble_index.size() != assemble_object.count) && (assemble_object.assemble_index.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s assemble_index count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.assemble_index.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_X)) {
+                    assemble_object.pos_x = object_json[JSON_ASSEMPLE_OBJECT_POS_X].get<std::vector<float>>();
+                    if ((assemble_object.pos_x.size() > 0) && (assemble_object.pos_x.size() != assemble_object.count) && (assemble_object.pos_x.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_x count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_x.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Y)) {
+                    assemble_object.pos_y = object_json[JSON_ASSEMPLE_OBJECT_POS_Y].get<std::vector<float>>();
+                    if ((assemble_object.pos_y.size() > 0) && (assemble_object.pos_y.size() != assemble_object.count) && (assemble_object.pos_y.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_y count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_y.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Z)) {
+                    assemble_object.pos_z = object_json[JSON_ASSEMPLE_OBJECT_POS_Z].get<std::vector<float>>();
+                    if ((assemble_object.pos_z.size() > 0) && (assemble_object.pos_z.size() != assemble_object.count) && (assemble_object.pos_z.size() != 1))
+                    {
+                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_z count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_z.size() % assemble_object.count;
+                        return CLI_CONFIG_FILE_ERROR;
+                    }
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
+                    assemble_object.print_params = object_json[JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
+                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% print params") % (plate_index + 1) %assemble_object.path % assemble_object.print_params.size();
+                }
+                if (object_json.contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
+                    json height_range_json = object_json[JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
+                    int range_count = height_range_json.size();
+
+                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% height ranges") % (plate_index + 1) %assemble_object.path % range_count;
+
+                    assemble_object.height_ranges.resize(range_count);
+                    for (int range_index = 0; range_index < range_count; range_index++)
+                    {
+                        height_range_info_t& height_range = assemble_object.height_ranges[range_index];
+                        height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
+                        height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
+                        height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
+                    }
+                }
+            }
+            if (plate_json.contains(JSON_ASSEMPLE_ASSEMBLE_PARAMS)) {
+                json assemble_params_json = plate_json[JSON_ASSEMPLE_ASSEMBLE_PARAMS];
+                int assemble_count = assemble_params_json.size();
+                for (int i = 0; i < assemble_count; i++)
+                {
+                    assembled_param_info_t assembled_param;
+                    int assemble_index = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX];
+                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
+                        assembled_param.print_params = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
+                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% print params") % (plate_index + 1) %i % assembled_param.print_params.size();
+                    }
+                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
+                        json height_range_json = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
+                        int range_count = height_range_json.size();
+
+                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% height ranges") % (plate_index + 1) %i % range_count;
+
+                        assembled_param.height_ranges.resize(range_count);
+                        for (int range_index = 0; range_index < range_count; range_index++)
+                        {
+                            height_range_info_t& height_range = assembled_param.height_ranges[range_index];
+                            height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
+                            height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
+                            height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
+                        }
+                    }
+                    assemble_plate.assembled_param_list.emplace(assemble_index, std::move(assembled_param));
+                }
+                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
+            }
+        }
+    }
+    catch(std::exception &err) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
+        ret = CLI_CONFIG_FILE_ERROR;
+    }
+
+    return ret;
+}
+
 void merge_or_add_object(assemble_plate_info_t& assemble_plate_info, Model &model, int assemble_index, std::map<int, ModelObject*> &merged_objects, ModelObject *ori_object)
 {
     if (assemble_index > 0) {
@@ -1707,14 +1863,6 @@ int CLI::run(int argc, char **argv)
 
                     BOOST_LOG_TRIVIAL(info) << boost::format("current_printer_name %1%, current_process_name %2%")%current_printer_name %current_process_name;
                     ConfigOptionStrings* option_strings = config.option<ConfigOptionStrings>("inherits_group");
-                    // One entry for the process, one per filament and one for the printer. A group of another
-                    // length still has the process first and the printer last; one too short for that is ignored.
-                    if (option_strings && option_strings->values.size() != current_filaments_name.size() + 2) {
-                        boost::nowide::cerr << "Warning: inherits_group has " << option_strings->values.size() << " entries, expected "
-                                            << current_filaments_name.size() + 2 << " for " << current_filaments_name.size() << " filaments" << std::endl;
-                        if (option_strings->values.size() < 2)
-                            option_strings = nullptr;
-                    }
                     if (option_strings) {
                         current_inherits_group = option_strings->values;
                         size_t size = current_inherits_group.size();
@@ -1736,11 +1884,14 @@ int CLI::run(int argc, char **argv)
                             BOOST_LOG_TRIVIAL(info) << boost::format("inherits of process valid, current_process_system_name is %1%") %current_process_system_name;
                         }
 
-                        // A filament without an entry of its own counts as a system preset.
-                        current_filaments_system_name = current_filaments_name;
-                        for (size_t index = 1; index < size - 1 && index <= current_filaments_name.size(); index++) {
-                            if (!current_inherits_group[index].empty())
+                        current_filaments_system_name.resize(size - 2);
+                        for (int index = 1; index < (size - 1); index++) {
+                            if (current_inherits_group[index].empty()) {
+                                current_filaments_system_name[index-1] = current_filaments_name[index-1];
+                            }
+                            else {
                                 current_filaments_system_name[index-1] = current_inherits_group[index];
+                            }
                         }
                     }
                     else {
@@ -1872,12 +2023,7 @@ int CLI::run(int argc, char **argv)
         //parse the json and assemble object here
         Model model;
 
-        AssembleListResult list_result = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list, MAX_PLATE_COUNT);
-        int ret = CLI_SUCCESS;
-        if (list_result == AssembleListResult::FileNotFound)
-            ret = CLI_FILE_NOTFOUND;
-        else if (list_result == AssembleListResult::ConfigError)
-            ret = CLI_CONFIG_FILE_ERROR;
+        int ret = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list);
         if (ret) {
             record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
             flush_and_exit(ret);
@@ -4587,11 +4733,6 @@ int CLI::run(int argc, char **argv)
                 record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                 flush_and_exit(CLI_INVALID_PARAMS);
             }
-            if (m_models.empty()) {
-                boost::nowide::cerr << "Invalid params: --assemble needs at least one input model." << std::endl;
-                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
-                flush_and_exit(CLI_INVALID_PARAMS);
-            }
             Model m;
             ModelObject* new_object = m.add_object();
             new_object->name = _u8L("Assembly");
@@ -5532,7 +5673,7 @@ int CLI::run(int argc, char **argv)
                         float w = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_tower_width"))->value;
                         float a = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("wipe_tower_rotation_angle"))->value;
                         float v = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_volume"))->value;
-                        unsigned int filaments_cnt = (plate_data_src.size() >= static_cast<size_t>(plate_to_slice)) ? plate_data_src[plate_to_slice-1]->slice_filaments_info.size() : 0;
+                        unsigned int filaments_cnt = plate_data_src[plate_to_slice-1]->slice_filaments_info.size();
                         if ((filaments_cnt == 0) || need_skip)
                         {
                             // slice filaments info invalid

src/OrcaSlicer.hpp

@@ -5,7 +5,6 @@
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Model.hpp"
-#include "libslic3r/Format/AssembleList.hpp"
 
 namespace Slic3r {
 
@@ -20,6 +19,64 @@ namespace IO {
     };
 }
 
+#define JSON_ASSEMPLE_PLATES                   "plates"
+#define JSON_ASSEMPLE_PLATE_PARAMS             "plate_params"
+#define JSON_ASSEMPLE_PLATE_NAME               "plate_name"
+#define JSON_ASSEMPLE_PLATE_NEED_ARRANGE       "need_arrange"
+#define JSON_ASSEMPLE_OBJECTS                  "objects"
+#define JSON_ASSEMPLE_OBJECT_PATH              "path"
+#define JSON_ASSEMPLE_OBJECT_COUNT             "count"
+#define JSON_ASSEMPLE_OBJECT_FILAMENTS         "filaments"
+#define JSON_ASSEMPLE_OBJECT_POS_X             "pos_x"
+#define JSON_ASSEMPLE_OBJECT_POS_Y             "pos_y"
+#define JSON_ASSEMPLE_OBJECT_POS_Z             "pos_z"
+#define JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX    "assemble_index"
+#define JSON_ASSEMPLE_OBJECT_PRINT_PARAMS      "print_params"
+#define JSON_ASSEMPLE_ASSEMBLE_PARAMS         "assembled_params"
+
+
+#define JSON_ASSEMPLE_OBJECT_MIN_Z              "min_z"
+#define JSON_ASSEMPLE_OBJECT_MAX_Z              "max_z"
+#define JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES      "height_ranges"
+#define JSON_ASSEMPLE_OBJECT_RANGE_PARAMS       "range_params"
+
+typedef struct _height_range_info {
+    float         min_z;
+    float         max_z;
+
+    std::map<std::string, std::string> range_params;
+}height_range_info_t;
+
+typedef struct _assembled_param_info {
+    std::map<std::string, std::string> print_params;
+    std::vector<height_range_info_t> height_ranges;
+}assembled_param_info_t;
+
+typedef struct _assemble_object_info {
+    std::string         path;
+    int                 count;
+
+    std::vector<int>    filaments;
+    std::vector<int>    assemble_index;
+    std::vector<float>  pos_x;
+    std::vector<float>  pos_y;
+    std::vector<float>  pos_z;
+    std::map<std::string, std::string> print_params;
+    std::vector<height_range_info_t> height_ranges;
+}assemble_object_info_t;
+
+typedef struct _assemble_plate_info {
+    std::string         plate_name;
+    bool                need_arrange {false};
+    int                 filaments_count {0};
+
+    std::map<std::string, std::string> plate_params;
+    std::vector<assemble_object_info_t> assemble_obj_list;
+    std::vector<ModelObject *> loaded_obj_list;
+    std::map<int, assembled_param_info_t> assembled_param_list;
+}assemble_plate_info_t;
+
+
 typedef struct _printer_plate_info {
     std::string         printer_name;
     int                 printable_width{0};

src/libslic3r/CMakeLists.txt

@@ -205,8 +205,6 @@ set(lisbslic3r_sources
     Format/3mf.hpp
     Format/AMF.cpp
     Format/AMF.hpp
-    Format/AssembleList.cpp
-    Format/AssembleList.hpp
     Format/DRC.cpp
     Format/DRC.hpp
     Format/bbs_3mf.cpp

src/libslic3r/Format/AssembleList.cpp

@@ -1,204 +0,0 @@
-#include "AssembleList.hpp"
-
-#include <algorithm>
-
-#include <boost/filesystem.hpp>
-#include <boost/format.hpp>
-#include <boost/log/trivial.hpp>
-#include <boost/nowide/fstream.hpp>
-
-#include "nlohmann/json.hpp"
-
-#define JSON_ASSEMPLE_PLATES                   "plates"
-#define JSON_ASSEMPLE_PLATE_PARAMS             "plate_params"
-#define JSON_ASSEMPLE_PLATE_NAME               "plate_name"
-#define JSON_ASSEMPLE_PLATE_NEED_ARRANGE       "need_arrange"
-#define JSON_ASSEMPLE_OBJECTS                  "objects"
-#define JSON_ASSEMPLE_OBJECT_PATH              "path"
-#define JSON_ASSEMPLE_OBJECT_COUNT             "count"
-#define JSON_ASSEMPLE_OBJECT_FILAMENTS         "filaments"
-#define JSON_ASSEMPLE_OBJECT_POS_X             "pos_x"
-#define JSON_ASSEMPLE_OBJECT_POS_Y             "pos_y"
-#define JSON_ASSEMPLE_OBJECT_POS_Z             "pos_z"
-#define JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX    "assemble_index"
-#define JSON_ASSEMPLE_OBJECT_PRINT_PARAMS      "print_params"
-#define JSON_ASSEMPLE_ASSEMBLE_PARAMS         "assembled_params"
-
-
-#define JSON_ASSEMPLE_OBJECT_MIN_Z              "min_z"
-#define JSON_ASSEMPLE_OBJECT_MAX_Z              "max_z"
-#define JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES      "height_ranges"
-#define JSON_ASSEMPLE_OBJECT_RANGE_PARAMS       "range_params"
-
-namespace Slic3r {
-
-using json = nlohmann::json;
-
-AssembleListResult load_assemble_plate_list(const std::string &config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list, int max_plate_count)
-{
-    AssembleListResult ret = AssembleListResult::Success;
-    boost::filesystem::path directory_path(config_file);
-
-    BOOST_LOG_TRIVIAL(info) << boost::format("%1% enter, file %2%")%__FUNCTION__ % config_file;
-    if (!boost::filesystem::exists(directory_path)) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("directory %1% not exist.")%config_file;
-        return AssembleListResult::FileNotFound;
-    }
-
-    try {
-        json root_json;
-        boost::nowide::ifstream ifs(config_file);
-        ifs >> root_json;
-        ifs.close();
-
-        int plate_count = root_json[JSON_ASSEMPLE_PLATES].size();
-        if ((plate_count <= 0) || (plate_count > max_plate_count)) {
-            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid plate count %1%")%plate_count;
-            return AssembleListResult::ConfigError;
-        }
-        assemble_plate_info_list.resize(plate_count);
-
-        for (int plate_index = 0; plate_index < plate_count; plate_index++)
-        {
-            assemble_plate_info_t &assemble_plate = assemble_plate_info_list[plate_index];
-            const json& plate_json = root_json[JSON_ASSEMPLE_PLATES][plate_index];
-            assemble_plate.plate_name = plate_json[JSON_ASSEMPLE_PLATE_NAME];
-            assemble_plate.need_arrange = plate_json[JSON_ASSEMPLE_PLATE_NEED_ARRANGE];
-
-            if (plate_json.contains(JSON_ASSEMPLE_PLATE_PARAMS)) {
-                assemble_plate.plate_params = plate_json[JSON_ASSEMPLE_PLATE_PARAMS].get<std::map<std::string, std::string>>();
-                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
-            }
-
-            int object_count = plate_json[JSON_ASSEMPLE_OBJECTS].size();
-            if (object_count <= 0) {
-                BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": invalid object count %1% in plate %2%")%object_count %(plate_index+1);
-                return AssembleListResult::ConfigError;
-            }
-
-            assemble_plate.assemble_obj_list.resize(object_count);
-            for (int object_index = 0; object_index < object_count; object_index++)
-            {
-                assemble_object_info_t& assemble_object = assemble_plate.assemble_obj_list[object_index];
-                const json& object_json = plate_json[JSON_ASSEMPLE_OBJECTS][object_index];
-
-                assemble_object.path = object_json[JSON_ASSEMPLE_OBJECT_PATH];
-                assemble_object.count = object_json[JSON_ASSEMPLE_OBJECT_COUNT];
-
-                if (assemble_object.count <= 0) {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": invalid object clone count %1% in plate %2% Object %3%") % assemble_object.count % (plate_index + 1) % assemble_object.path;
-                    return AssembleListResult::ConfigError;
-                }
-
-                assemble_object.filaments = object_json.at(JSON_ASSEMPLE_OBJECT_FILAMENTS).get<std::vector<int>>();
-                if (assemble_object.filaments.empty())
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments list is empty") % assemble_object.path;
-                    return AssembleListResult::ConfigError;
-                }
-                if ((assemble_object.filaments.size() != assemble_object.count) && (assemble_object.filaments.size() != 1))
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s filaments count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.filaments.size() % assemble_object.count;
-                    return AssembleListResult::ConfigError;
-                }
-                // 0 keeps the default filament, as it does for --load-filament-ids.
-                if (std::any_of(assemble_object.filaments.begin(), assemble_object.filaments.end(), [](int id) { return id < 0; }))
-                {
-                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1% has a negative filament id") % assemble_object.path;
-                    return AssembleListResult::ConfigError;
-                }
-
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX)) {
-                    assemble_object.assemble_index = object_json[JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX].get<std::vector<int>>();
-                    if ((assemble_object.assemble_index.size() > 0) && (assemble_object.assemble_index.size() != assemble_object.count) && (assemble_object.assemble_index.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s assemble_index count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.assemble_index.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_X)) {
-                    assemble_object.pos_x = object_json[JSON_ASSEMPLE_OBJECT_POS_X].get<std::vector<float>>();
-                    if ((assemble_object.pos_x.size() > 0) && (assemble_object.pos_x.size() != assemble_object.count) && (assemble_object.pos_x.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_x count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_x.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Y)) {
-                    assemble_object.pos_y = object_json[JSON_ASSEMPLE_OBJECT_POS_Y].get<std::vector<float>>();
-                    if ((assemble_object.pos_y.size() > 0) && (assemble_object.pos_y.size() != assemble_object.count) && (assemble_object.pos_y.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_y count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_y.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_POS_Z)) {
-                    assemble_object.pos_z = object_json[JSON_ASSEMPLE_OBJECT_POS_Z].get<std::vector<float>>();
-                    if ((assemble_object.pos_z.size() > 0) && (assemble_object.pos_z.size() != assemble_object.count) && (assemble_object.pos_z.size() != 1))
-                    {
-                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": object %1%'s pos_z count %2% not equal to clone count %3%, also not equal to 1") % assemble_object.path % assemble_object.pos_z.size() % assemble_object.count;
-                        return AssembleListResult::ConfigError;
-                    }
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
-                    assemble_object.print_params = object_json[JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
-                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% print params") % (plate_index + 1) %assemble_object.path % assemble_object.print_params.size();
-                }
-                if (object_json.contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
-                    json height_range_json = object_json[JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
-                    int range_count = height_range_json.size();
-
-                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% has %3% height ranges") % (plate_index + 1) %assemble_object.path % range_count;
-
-                    assemble_object.height_ranges.resize(range_count);
-                    for (int range_index = 0; range_index < range_count; range_index++)
-                    {
-                        height_range_info_t& height_range = assemble_object.height_ranges[range_index];
-                        height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
-                        height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
-                        height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
-                    }
-                }
-            }
-            if (plate_json.contains(JSON_ASSEMPLE_ASSEMBLE_PARAMS)) {
-                json assemble_params_json = plate_json[JSON_ASSEMPLE_ASSEMBLE_PARAMS];
-                int assemble_count = assemble_params_json.size();
-                for (int i = 0; i < assemble_count; i++)
-                {
-                    assembled_param_info_t assembled_param;
-                    int assemble_index = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_ASSEMBLE_INDEX];
-                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_PRINT_PARAMS)) {
-                        assembled_param.print_params = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_PRINT_PARAMS].get<std::map<std::string, std::string>>();
-                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% print params") % (plate_index + 1) %i % assembled_param.print_params.size();
-                    }
-                    if (assemble_params_json[i].contains(JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES)) {
-                        json height_range_json = assemble_params_json[i][JSON_ASSEMPLE_OBJECT_HEIGHT_RANGES];
-                        int range_count = height_range_json.size();
-
-                        BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% has %3% height ranges") % (plate_index + 1) %i % range_count;
-
-                        assembled_param.height_ranges.resize(range_count);
-                        for (int range_index = 0; range_index < range_count; range_index++)
-                        {
-                            height_range_info_t& height_range = assembled_param.height_ranges[range_index];
-                            height_range.min_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MIN_Z];
-                            height_range.max_z = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_MAX_Z];
-                            height_range.range_params = height_range_json[range_index][JSON_ASSEMPLE_OBJECT_RANGE_PARAMS].get<std::map<std::string, std::string>>();
-                        }
-                    }
-                    assemble_plate.assembled_param_list.emplace(assemble_index, std::move(assembled_param));
-                }
-                BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, has %2% plate params") % (plate_index + 1)  % assemble_plate.plate_params.size();
-            }
-        }
-    }
-    catch(std::exception &err) {
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
-        ret = AssembleListResult::ConfigError;
-    }
-
-    return ret;
-}
-
-} // namespace Slic3r

src/libslic3r/Format/AssembleList.hpp

@@ -1,60 +0,0 @@
-#ifndef slic3r_Format_AssembleList_hpp_
-#define slic3r_Format_AssembleList_hpp_
-
-#include <map>
-#include <string>
-#include <vector>
-
-namespace Slic3r {
-
-class ModelObject;
-
-typedef struct _height_range_info {
-    float         min_z;
-    float         max_z;
-
-    std::map<std::string, std::string> range_params;
-}height_range_info_t;
-
-typedef struct _assembled_param_info {
-    std::map<std::string, std::string> print_params;
-    std::vector<height_range_info_t> height_ranges;
-}assembled_param_info_t;
-
-typedef struct _assemble_object_info {
-    std::string         path;
-    int                 count;
-
-    std::vector<int>    filaments;
-    std::vector<int>    assemble_index;
-    std::vector<float>  pos_x;
-    std::vector<float>  pos_y;
-    std::vector<float>  pos_z;
-    std::map<std::string, std::string> print_params;
-    std::vector<height_range_info_t> height_ranges;
-}assemble_object_info_t;
-
-typedef struct _assemble_plate_info {
-    std::string         plate_name;
-    bool                need_arrange {false};
-    int                 filaments_count {0};
-
-    std::map<std::string, std::string> plate_params;
-    std::vector<assemble_object_info_t> assemble_obj_list;
-    std::vector<ModelObject *> loaded_obj_list;
-    std::map<int, assembled_param_info_t> assembled_param_list;
-}assemble_plate_info_t;
-
-enum class AssembleListResult {
-    Success,
-    FileNotFound,
-    // Malformed JSON, a missing required field, or a value that fails validation.
-    ConfigError
-};
-
-// Read the JSON assemble list used by the CLI's --load-assemble-list into one entry per plate.
-AssembleListResult load_assemble_plate_list(const std::string &config_file, std::vector<assemble_plate_info_t> &assemble_plate_info_list, int max_plate_count);
-
-} // namespace Slic3r
-
-#endif /* slic3r_Format_AssembleList_hpp_ */

src/libslic3r/Utils.hpp

@@ -260,6 +260,12 @@ extern bool is_json_file(const std::string& path);
 // Both '/' and '\\' are treated as separators on every platform, so an archive rejected on one OS
 // is rejected on all of them.
 extern bool is_path_within_root(const std::string &rel_path, const boost::filesystem::path &root);
+// True if path names an entry strictly inside root: it must be spelled with root as its prefix,
+// and must still resolve inside root once symlinks are followed.
+extern bool is_absolute_path_within_root(const boost::filesystem::path &path, const boost::filesystem::path &root);
+// True if a file with this name is of a type that the desktop opens as plain content, so it cannot run code.
+// Anything unknown is not safe.
+extern bool is_safe_to_open_file_name(const std::string &file_name);
 
 // Orca: custom protocal support utils
 inline bool is_orca_open(const std::string& url) { return boost::starts_with(url, "orcaslicer://open"); }

src/libslic3r/utils.cpp

@@ -70,6 +70,7 @@
 #include <boost/shared_ptr.hpp>
 
 #include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/nowide/fstream.hpp>
@@ -1112,6 +1113,28 @@ bool is_path_within_root(const std::string &rel_path, const boost::filesystem::p
     }
 }
 
+bool is_absolute_path_within_root(const boost::filesystem::path &path, const boost::filesystem::path &root)
+{
+    const boost::filesystem::path rel = path.lexically_relative(root);
+    return !rel.empty() && rel != "." && is_path_within_root(rel.string(), root);
+}
+
+bool is_safe_to_open_file_name(const std::string &file_name)
+{
+    // Formats that cannot carry macros or scripts. Legacy and OpenDocument office files, HTML and SVG are left out on purpose.
+    static const std::vector<std::string> safe_extensions = {
+        "jpg", "jpeg", "jfif", "pjpeg", "pjp", "png", "gif", "bmp", "webp", "tif", "tiff",
+        "pdf", "txt", "md", "csv", "docx", "xlsx", "pptx",
+        "stl", "obj", "3mf", "amf", "ply", "step", "stp", "iges", "igs", "dxf",
+        "mp4", "mov", "webm"};
+    // The name must end in the extension itself: Windows drops trailing dots and spaces and reads ':' as a stream separator.
+    const size_t dot = file_name.find_last_of('.');
+    if (dot == std::string::npos || file_name.find_first_of("/\\:") != std::string::npos)
+        return false;
+    const std::string extension = boost::algorithm::to_lower_copy(file_name.substr(dot + 1));
+    return std::find(safe_extensions.begin(), safe_extensions.end(), extension) != safe_extensions.end();
+}
+
 bool is_img_file(const std::string &path)
 {
 	return boost::iends_with(path, ".png") || boost::iends_with(path, ".svg");

src/slic3r/GUI/Auxiliary.cpp

@@ -428,7 +428,7 @@ void AuFile::on_dclick(wxMouseEvent &evt)
     if (m_type == AddFileButton)
         return;
     else
-        wxLaunchDefaultApplication(m_file_path.wstring(), 0);
+        desktop_open_project_attachment(this, m_file_path);
 }
 
 void AuFile::on_mouse_left_up(wxMouseEvent &evt)

src/slic3r/GUI/GUI.cpp

@@ -27,11 +27,13 @@
 
 #include "AboutDialog.hpp"
 #include "MsgDialog.hpp"
+#include "Plater.hpp"
 #include "format.hpp"
 
 #include "WebUserLoginDialog.hpp"
 
 #include "libslic3r/Print.hpp"
+#include "libslic3r/Utils.hpp"
 
 namespace Slic3r {
 
@@ -635,4 +637,26 @@ void desktop_open_any_folder( const std::string& path )
 }
 
 
+bool desktop_open_project_attachment(wxWindow *parent, const boost::filesystem::path &path)
+{
+    // The auxiliary path is UTF-8, which is what boost::filesystem reads a narrow string as.
+    const boost::filesystem::path aux_root(wxGetApp().plater()->model().get_auxiliary_file_temp_path());
+    boost::system::error_code ec;
+    if (!is_absolute_path_within_root(path, aux_root) || !boost::filesystem::is_regular_file(path, ec))
+        return false;
+
+    // Attachments come with the project and carry no download mark, so the desktop would open them without a warning.
+    if (!is_safe_to_open_file_name(path.filename().string())) {
+        MessageDialog dlg(parent,
+                          wxString::Format(_L("\"%s\" is not a plain document, image or model file. Opening it may run it as a "
+                                              "program or script on this computer.\n\n"
+                                              "Only open attachments from projects you trust. Open it anyway?"),
+                                           from_path(path.filename())),
+                          _L("Open attachment"), wxICON_WARNING | wxYES_NO);
+        if (dlg.ShowModal() != wxID_YES)
+            return false;
+    }
+    return wxLaunchDefaultApplication(from_path(path), 0);
+}
+
 } }

src/slic3r/GUI/GUI.hpp

@@ -83,6 +83,9 @@ extern void about();
 extern void desktop_open_datadir_folder();
 // Ask the destop to open one folder
 extern void desktop_open_any_folder(const std::string& path);
+// Ask the desktop to open a file from the project's auxiliary directory, after a confirmation
+// unless its type is known to be plain content. Returns false if the file was not opened.
+extern bool desktop_open_project_attachment(wxWindow *parent, const boost::filesystem::path &path);
 } // namespace GUI
 } // namespace Slic3r
 

src/slic3r/GUI/Project.cpp

@@ -293,10 +293,8 @@ void ProjectPanel::OnScriptMessage(wxWebViewEvent& evt)
             if (!accessory_path.empty()) {
                 std::string decode_path = wxGetApp().url_decode(accessory_path.ToStdString());
                 fs::path path(decode_path);
-
-                if (fs::exists(path)) {
-                    wxLaunchDefaultApplication(path.wstring(), 0);
-                }
+                if (!desktop_open_project_attachment(this, path))
+                    BOOST_LOG_TRIVIAL(warning) << "open_3mf_accessory: not opening " << decode_path;
             }
         }
         else if (strCmd == "request_3mf_info") {

tests/cli/CMakeLists.txt

@@ -15,10 +15,3 @@ set_tests_properties(cli_strict_mode PROPERTIES
     LABELS "CLI;RequiresApp"
     SKIP_RETURN_CODE 77
     TIMEOUT 900)
-
-add_test(NAME cli_malformed_input
-    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_malformed_input.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON})
-set_tests_properties(cli_malformed_input PROPERTIES
-    LABELS "CLI;RequiresApp"
-    SKIP_RETURN_CODE 77
-    TIMEOUT 900)

tests/cli/test_cli_malformed_input.sh

@@ -1,207 +0,0 @@
-#!/usr/bin/env bash
-# End-to-end checks that malformed CLI input fails cleanly, or loads, instead of crashing the
-# orca-slicer binary. Each case lives inline in CLI::run(), so only the binary can reach it.
-#
-# - A project whose inherits_group does not have one entry per filament plus the process and
-#   printer entries still loads.
-# - --slice N --arrange 1 on a project without plate metadata slices plate N.
-# - An assemble list object with an empty filament list, or a negative filament id, is rejected
-#   as a config error.
-# - --assemble with no input model is rejected as invalid parameters.
-#
-# usage: test_cli_malformed_input.sh <orca-slicer binary> <python3>
-set -u
-
-BIN="${1:-}"
-PY="${2:-python3}"
-# 77 is the test's SKIP_RETURN_CODE.
-[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
-
-# From src/libslic3r/Utils.hpp. main() returns them, so the shell sees them modulo 256.
-CLI_SUCCESS=0
-CLI_INVALID_PARAMS=-2
-CLI_CONFIG_FILE_ERROR=-5
-
-WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-malformed.XXXXXX")"
-trap 'rm -rf "$WORK"' EXIT
-mkdir -p "$WORK/datadir"
-
-# Standalone presets: without "inherits" the CLI loads them as-is, with no preset bundle.
-cat > "$WORK/machine.json" <<'EOF'
-{
-    "type": "machine",
-    "from": "User",
-    "name": "CLI malformed input test printer",
-    "printable_area": ["0x0", "200x0", "200x200", "0x200"],
-    "printable_height": "100",
-    "layer_change_gcode": "G92 E0"
-}
-EOF
-cat > "$WORK/process.json" <<'EOF'
-{
-    "type": "process",
-    "from": "User",
-    "name": "CLI malformed input test process"
-}
-EOF
-cat > "$WORK/filament.json" <<'EOF'
-{
-    "type": "filament",
-    "from": "User",
-    "name": "CLI malformed input test filament"
-}
-EOF
-
-"$PY" - "$WORK/cube.stl" <<'EOF'
-import sys
-
-v = [(x, y, z) for z in (0, 10) for y in (0, 10) for x in (0, 10)]
-with open(sys.argv[1], "w") as f:
-    f.write("solid cube\n")
-    # Faces wound counter-clockwise seen from outside: -z, +z, -y, +y, -x, +x.
-    for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
-        for tri in ((a, b, c), (a, c, d)):
-            f.write("facet normal 0 0 0\nouter loop\n")
-            for i in tri:
-                f.write("vertex %g %g %g\n" % v[i])
-            f.write("endloop\nendfacet\n")
-    f.write("endsolid cube\n")
-EOF
-
-fails=0
-fail() { echo "FAIL: $*"; fails=$((fails + 1)); }
-
-# run <tag> [option...]: run into $WORK/<tag>, keeping the log and the shell status there.
-run() {
-    local out="$WORK/$1"; shift
-    mkdir -p "$out"
-    timeout 300 "$BIN" --datadir "$WORK/datadir" --outputdir "$out" "$@" > "$out/log" 2>&1
-    echo $? > "$out/status"
-}
-
-# run_presets <tag> [option...]: run with the standalone presets loaded.
-run_presets() {
-    local tag="$1"; shift
-    run "$tag" --load-settings "$WORK/machine.json;$WORK/process.json" --load-filaments "$WORK/filament.json" "$@"
-}
-
-# expect_status <tag> <cli code>
-expect_status() {
-    local got; got="$(cat "$WORK/$1/status")"
-    [ "$got" -eq $(( $2 & 255 )) ] || fail "$1: shell status $got, want $(( $2 & 255 )) (code $2)"
-}
-
-# expect_result <tag> <return_code>: a failing run must also carry an error_string.
-expect_result() {
-    "$PY" - "$WORK/$1/result.json" "$2" <<'EOF' || fail "$1: result.json"
-import json, sys
-
-try:
-    with open(sys.argv[1]) as f:
-        result = json.load(f)
-except (OSError, ValueError) as e:
-    sys.exit("cannot read %s: %s" % (sys.argv[1], e))
-want_rc = int(sys.argv[2])
-if result.get("return_code") != want_rc:
-    sys.exit("return_code %r, want %d" % (result.get("return_code"), want_rc))
-if want_rc != 0 and not result.get("error_string"):
-    sys.exit("no error_string")
-EOF
-}
-
-# expect_log <tag> <text>
-expect_log() {
-    grep -qF -- "$2" "$WORK/$1/log" || fail "$1: log does not mention \"$2\""
-}
-
-# expect_gcode <tag>
-expect_gcode() {
-    compgen -G "$WORK/$1/*.gcode" > /dev/null || fail "$1: no G-code was exported"
-}
-
-# rewrite_3mf <in> <out> inherits <json list> | no-plates
-rewrite_3mf() {
-    "$PY" - "$@" <<'EOF'
-import json, re, sys, zipfile
-
-src, dst, mode = sys.argv[1:4]
-with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
-    for info in zin.infolist():
-        data = zin.read(info.filename)
-        if mode == "inherits" and info.filename == "Metadata/project_settings.config":
-            config = json.loads(data)
-            config["inherits_group"] = json.loads(sys.argv[4])
-            data = json.dumps(config, indent=4).encode()
-        elif mode == "no-plates":
-            if re.match(r"Metadata/plate_\d+\.", info.filename):
-                continue
-            if info.filename == "Metadata/model_settings.config":
-                data = re.sub(rb"\s*<plate>.*?</plate>", b"", data, flags=re.S)
-        zout.writestr(info, data)
-EOF
-}
-
-# assemble_list <file> <filaments json>
-assemble_list() {
-    cat > "$1" <<EOF
-{"plates": [{"plate_name": "p", "need_arrange": false,
-             "objects": [{"path": "$WORK/cube.stl", "count": 1, "filaments": $2,
-                          "pos_x": [100], "pos_y": [100]}]}]}
-EOF
-}
-
-echo "== a one-filament project exported by the CLI is the base for the project cases"
-run_presets export --slice 0 --export-3mf project.3mf "$WORK/cube.stl"
-expect_status export $CLI_SUCCESS
-[ -f "$WORK/export/project.3mf" ] || { echo "FAIL: project export failed"; tail -n 40 "$WORK/export/log"; exit 1; }
-
-echo "== an inherits_group of the wrong length still loads"
-for group in '[]' '[""]' '["", "", "", "", ""]'; do
-    tag="inherits_$("$PY" -c 'import json, sys; print(len(json.loads(sys.argv[1])))' "$group")"
-    rewrite_3mf "$WORK/export/project.3mf" "$WORK/$tag.3mf" inherits "$group"
-    run "$tag" --info "$WORK/$tag.3mf"
-    expect_status "$tag" $CLI_SUCCESS
-    expect_log "$tag" "inherits_group"
-done
-
-echo "== --slice 1 --arrange 1 slices a project without plate metadata"
-rewrite_3mf "$WORK/export/project.3mf" "$WORK/no_plates.3mf" no-plates
-run_presets no_plates --slice 1 --arrange 1 "$WORK/no_plates.3mf"
-expect_status no_plates $CLI_SUCCESS
-expect_result no_plates $CLI_SUCCESS
-expect_gcode no_plates
-
-echo "== an assemble list with a valid filament id slices"
-assemble_list "$WORK/assemble_valid.json" '[1]'
-run_presets assemble_valid --slice 0 --load-assemble-list "$WORK/assemble_valid.json"
-expect_status assemble_valid $CLI_SUCCESS
-expect_gcode assemble_valid
-
-echo "== an assemble list with an empty filament list or a negative filament id is rejected"
-for filaments in '[]' '[-1]'; do
-    if [ "$filaments" = '[]' ]; then tag=assemble_empty; else tag=assemble_negative; fi
-    assemble_list "$WORK/$tag.json" "$filaments"
-    run_presets "$tag" --slice 0 --load-assemble-list "$WORK/$tag.json"
-    expect_status "$tag" $CLI_CONFIG_FILE_ERROR
-    expect_result "$tag" $CLI_CONFIG_FILE_ERROR
-done
-
-echo "== --assemble with no input model is rejected"
-for action in "--slice 0" "--export-3mf out.3mf"; do
-    tag="assemble_no_input_${action%% *}"
-    tag="${tag//-/}"
-    # shellcheck disable=SC2086
-    run_presets "$tag" --assemble $action
-    expect_status "$tag" $CLI_INVALID_PARAMS
-    expect_result "$tag" $CLI_INVALID_PARAMS
-    expect_log "$tag" "--assemble"
-done
-
-if [ "$fails" -ne 0 ]; then
-    for log in "$WORK"/*/log; do
-        echo "--- $log"
-        tail -n 40 "$log"
-    done
-    exit 1
-fi
-echo "PASS"

tests/libslic3r/CMakeLists.txt

@@ -7,7 +7,6 @@ add_executable(${_TEST_NAME}_tests
     test_appconfig.cpp
     test_arachne_walls.cpp
     test_arrange.cpp
-    test_assemble_list.cpp
     test_bambu_networking.cpp
     test_buildvolume.cpp
     test_calib.cpp

tests/libslic3r/test_assemble_list.cpp

@@ -1,266 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include "libslic3r/Format/AssembleList.hpp"
-
-#include "test_utils.hpp"
-
-#include <boost/nowide/fstream.hpp>
-#include <nlohmann/json.hpp>
-
-#include <string>
-#include <vector>
-
-using namespace Slic3r;
-using Catch::Matchers::WithinAbs;
-using nlohmann::json;
-
-static constexpr int max_plates = 36;
-
-static AssembleListResult load_text(const std::string &text, std::vector<assemble_plate_info_t> &plates)
-{
-    ScopedTemporaryFile file(".json");
-    {
-        boost::nowide::ofstream out(file.string());
-        out << text;
-    }
-    return load_assemble_plate_list(file.string(), plates, max_plates);
-}
-
-static AssembleListResult load_json(const json &root)
-{
-    std::vector<assemble_plate_info_t> plates;
-    return load_text(root.dump(), plates);
-}
-
-// One plate with one object of three clones, which every optional field accepts.
-static json valid_list()
-{
-    return json::parse(R"({
-        "plates": [{
-            "plate_name": "plate",
-            "need_arrange": false,
-            "objects": [{
-                "path": "cube.stl",
-                "count": 3,
-                "filaments": [1],
-                "height_ranges": [{ "min_z": 0, "max_z": 5, "range_params": { "layer_height": "0.1" } }]
-            }],
-            "assembled_params": [{
-                "assemble_index": 1,
-                "height_ranges": [{ "min_z": 0, "max_z": 5, "range_params": { "layer_height": "0.1" } }]
-            }]
-        }]
-    })");
-}
-
-TEST_CASE("A valid assemble list parses into its plates and objects", "[AssembleList]")
-{
-    const std::string text = R"({
-        "plates": [
-            {
-                "plate_name": "first",
-                "need_arrange": true,
-                "plate_params": { "curr_bed_type": "Textured PEI Plate" },
-                "objects": [
-                    {
-                        "path": "a.stl",
-                        "count": 2,
-                        "filaments": [1, 3],
-                        "assemble_index": [1],
-                        "pos_x": [10.5, 20.5],
-                        "pos_y": [30],
-                        "pos_z": [0, 1],
-                        "print_params": { "sparse_infill_density": "30%" },
-                        "height_ranges": [{ "min_z": 1.5, "max_z": 4, "range_params": { "layer_height": "0.12" } }]
-                    },
-                    { "path": "b.stl", "count": 1, "filaments": [0] }
-                ],
-                "assembled_params": [{ "assemble_index": 1, "print_params": { "wall_loops": "4" } }]
-            },
-            {
-                "plate_name": "second",
-                "need_arrange": false,
-                "objects": [{ "path": "c.stl", "count": 1, "filaments": [2] }]
-            }
-        ]
-    })";
-    std::vector<assemble_plate_info_t> plates;
-    REQUIRE(load_text(text, plates) == AssembleListResult::Success);
-    REQUIRE(plates.size() == 2);
-
-    const assemble_plate_info_t &first = plates[0];
-    CHECK(first.plate_name == "first");
-    CHECK(first.need_arrange);
-    CHECK(first.plate_params.at("curr_bed_type") == "Textured PEI Plate");
-    REQUIRE(first.assemble_obj_list.size() == 2);
-
-    const assemble_object_info_t &a = first.assemble_obj_list[0];
-    CHECK(a.path == "a.stl");
-    CHECK(a.count == 2);
-    CHECK(a.filaments == std::vector<int>{1, 3});
-    CHECK(a.assemble_index == std::vector<int>{1});
-    REQUIRE(a.pos_x.size() == 2);
-    CHECK_THAT(a.pos_x[0], WithinAbs(10.5, 1e-6));
-    CHECK_THAT(a.pos_x[1], WithinAbs(20.5, 1e-6));
-    REQUIRE(a.pos_y.size() == 1);
-    CHECK_THAT(a.pos_y[0], WithinAbs(30., 1e-6));
-    REQUIRE(a.pos_z.size() == 2);
-    CHECK_THAT(a.pos_z[1], WithinAbs(1., 1e-6));
-    CHECK(a.print_params.at("sparse_infill_density") == "30%");
-    REQUIRE(a.height_ranges.size() == 1);
-    CHECK_THAT(a.height_ranges[0].min_z, WithinAbs(1.5, 1e-6));
-    CHECK_THAT(a.height_ranges[0].max_z, WithinAbs(4., 1e-6));
-    CHECK(a.height_ranges[0].range_params.at("layer_height") == "0.12");
-
-    const assemble_object_info_t &b = first.assemble_obj_list[1];
-    CHECK(b.path == "b.stl");
-    CHECK(b.count == 1);
-    CHECK(b.filaments == std::vector<int>{0});
-    CHECK(b.pos_x.empty());
-    CHECK(b.assemble_index.empty());
-
-    REQUIRE(first.assembled_param_list.count(1) == 1);
-    CHECK(first.assembled_param_list.at(1).print_params.at("wall_loops") == "4");
-
-    const assemble_plate_info_t &second = plates[1];
-    CHECK(second.plate_name == "second");
-    CHECK_FALSE(second.need_arrange);
-    REQUIRE(second.assemble_obj_list.size() == 1);
-    CHECK(second.assemble_obj_list[0].path == "c.stl");
-    CHECK(second.assemble_obj_list[0].filaments == std::vector<int>{2});
-}
-
-TEST_CASE("The unmodified fixture used by the rule tests is accepted", "[AssembleList]")
-{
-    CHECK(load_json(valid_list()) == AssembleListResult::Success);
-}
-
-TEST_CASE("An object with an empty filament list is rejected", "[AssembleList]")
-{
-    json root = valid_list();
-    root["plates"][0]["objects"][0]["filaments"] = json::array();
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("An object with a negative filament id is rejected", "[AssembleList]")
-{
-    json root = valid_list();
-    root["plates"][0]["objects"][0]["filaments"] = GENERATE(json::array({-1}), json::array({1, -2, 1}));
-    CAPTURE(root["plates"][0]["objects"][0]["filaments"].dump());
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("Filament id 0 is accepted", "[AssembleList]")
-{
-    json root = valid_list();
-    root["plates"][0]["objects"][0]["filaments"] = GENERATE(json::array({0}), json::array({0, 1, 0}));
-    CAPTURE(root["plates"][0]["objects"][0]["filaments"].dump());
-    CHECK(load_json(root) == AssembleListResult::Success);
-}
-
-TEST_CASE("Per-clone lists need one entry or one per clone", "[AssembleList]")
-{
-    // The fixture object has 3 clones.
-    const std::string key  = GENERATE("filaments", "assemble_index", "pos_x", "pos_y", "pos_z");
-    const size_t      size = GENERATE(1, 2, 3, 4);
-    CAPTURE(key, size);
-
-    json root = valid_list();
-    root["plates"][0]["objects"][0][key] = json(std::vector<int>(size, 1));
-    const AssembleListResult expected = (size == 1 || size == 3) ? AssembleListResult::Success : AssembleListResult::ConfigError;
-    CHECK(load_json(root) == expected);
-}
-
-TEST_CASE("An empty optional per-clone list is accepted", "[AssembleList]")
-{
-    const std::string key = GENERATE("assemble_index", "pos_x", "pos_y", "pos_z");
-    CAPTURE(key);
-
-    json root = valid_list();
-    root["plates"][0]["objects"][0][key] = json::array();
-    CHECK(load_json(root) == AssembleListResult::Success);
-}
-
-// Fields read through a const reference (plate_name, need_arrange, objects, path, count) are
-// looked up without a presence check, so only their wrong-type case is covered here.
-TEST_CASE("A missing required field is rejected", "[AssembleList]")
-{
-    const std::string pointer = GENERATE("/plates",
-                                         "/plates/0/objects/0/filaments",
-                                         "/plates/0/objects/0/height_ranges/0/min_z",
-                                         "/plates/0/objects/0/height_ranges/0/max_z",
-                                         "/plates/0/objects/0/height_ranges/0/range_params",
-                                         "/plates/0/assembled_params/0/assemble_index",
-                                         "/plates/0/assembled_params/0/height_ranges/0/min_z",
-                                         "/plates/0/assembled_params/0/height_ranges/0/max_z",
-                                         "/plates/0/assembled_params/0/height_ranges/0/range_params");
-    CAPTURE(pointer);
-
-    json root = valid_list();
-    const json::json_pointer ptr(pointer);
-    root[ptr.parent_pointer()].erase(ptr.back());
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("A field of the wrong type is rejected", "[AssembleList]")
-{
-    const std::string pointer = GENERATE("/plates/0/plate_name",
-                                         "/plates/0/need_arrange",
-                                         "/plates/0/objects/0/path",
-                                         "/plates/0/objects/0/count",
-                                         "/plates/0/objects/0/filaments",
-                                         "/plates/0/objects/0/pos_x");
-    CAPTURE(pointer);
-
-    json root = valid_list();
-    root[json::json_pointer(pointer)] = json::object();
-    CHECK(load_json(root) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("A plate or clone count out of range is rejected", "[AssembleList]")
-{
-    SECTION("no plates")
-    {
-        json root = valid_list();
-        root["plates"] = json::array();
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-    SECTION("more plates than the limit")
-    {
-        json root = valid_list();
-        const json plate = root["plates"][0];
-        for (int i = 1; i < max_plates; ++i)
-            root["plates"].push_back(plate);
-        CHECK(load_json(root) == AssembleListResult::Success);
-        root["plates"].push_back(plate);
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-    SECTION("a plate with no objects")
-    {
-        json root = valid_list();
-        root["plates"][0]["objects"] = json::array();
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-    SECTION("a clone count below 1")
-    {
-        json root = valid_list();
-        root["plates"][0]["objects"][0]["count"] = GENERATE(0, -1);
-        CAPTURE(root["plates"][0]["objects"][0]["count"].dump());
-        CHECK(load_json(root) == AssembleListResult::ConfigError);
-    }
-}
-
-TEST_CASE("Malformed JSON is rejected", "[AssembleList]")
-{
-    const std::string text = GENERATE(std::string(), std::string("{\"plates\": ["), std::string("not json"));
-    CAPTURE(text);
-    std::vector<assemble_plate_info_t> plates;
-    CHECK(load_text(text, plates) == AssembleListResult::ConfigError);
-}
-
-TEST_CASE("A missing file is reported as not found", "[AssembleList]")
-{
-    ScopedTemporaryFile        file(".json");
-    std::vector<assemble_plate_info_t> plates;
-    CHECK(load_assemble_plate_list(file.string(), plates, max_plates) == AssembleListResult::FileNotFound);
-}

tests/libslic3r/test_utils.cpp

@@ -152,3 +152,68 @@ TEST_CASE("resolve_cli_input_path leaves inputs that must not be completed uncha
         REQUIRE(resolve_cli_input_path("").empty());
     }
 }
+
+TEST_CASE("is_absolute_path_within_root accepts only entries inside the root", "[utils]") {
+    namespace fs = boost::filesystem;
+    ScopedTemporaryDir outer;
+    const fs::path root = outer.path() / "Auxiliaries";
+    fs::create_directories(root / "Others");
+    const fs::path inside = root / "Others" / "note.txt";
+    const fs::path outside = outer.path() / "secret.txt";
+    std::ofstream(inside.string()) << "inside";
+    std::ofstream(outside.string()) << "outside";
+
+    SECTION("a file inside the root") {
+        REQUIRE(is_absolute_path_within_root(inside, root));
+    }
+    SECTION("a path inside the root whose file does not exist yet") {
+        REQUIRE(is_absolute_path_within_root(root / "Others" / "missing.txt", root));
+    }
+    SECTION("the root itself") {
+        REQUIRE_FALSE(is_absolute_path_within_root(root, root));
+    }
+    SECTION("a parent-directory escape spelled under the root") {
+        REQUIRE_FALSE(is_absolute_path_within_root(root / "Others" / ".." / ".." / "secret.txt", root));
+    }
+    SECTION("an absolute path elsewhere") {
+        REQUIRE_FALSE(is_absolute_path_within_root(outside, root));
+    }
+    SECTION("a sibling directory sharing the root's name as a prefix") {
+        const fs::path sibling = outer.path() / "Auxiliaries2" / "note.txt";
+        REQUIRE_FALSE(is_absolute_path_within_root(sibling, root));
+    }
+    SECTION("a relative path") {
+        REQUIRE_FALSE(is_absolute_path_within_root(fs::path("Others") / "note.txt", root));
+    }
+    SECTION("an empty path") {
+        REQUIRE_FALSE(is_absolute_path_within_root(fs::path(), root));
+    }
+#ifndef _WIN32
+    // Creating symlinks on Windows needs elevated rights or developer mode.
+    SECTION("a symlink inside the root that points outside") {
+        const fs::path link = root / "Others" / "link.txt";
+        fs::create_symlink(outside, link);
+        REQUIRE_FALSE(is_absolute_path_within_root(link, root));
+    }
+#endif
+}
+
+TEST_CASE("is_safe_to_open_file_name accepts plain documents, images and models", "[utils]") {
+    const std::string safe = GENERATE(as<std::string>{},
+        "Manual.pdf", "BOM.xlsx", "BOM.csv", "guide.docx", "notes.txt", "README.md", "photo.JPG", "render.png",
+        "assembly.step", "part.stl", "project.3mf", "drawing.dxf", "build.mp4", "setup.exe.pdf", ".pdf");
+    INFO(safe);
+    CHECK(is_safe_to_open_file_name(safe));
+}
+
+TEST_CASE("is_safe_to_open_file_name rejects programs and anything it does not know", "[utils]") {
+    const std::string unsafe = GENERATE(as<std::string>{},
+        "setup.exe", "SETUP.EXE", "Manual.pdf.exe", "run.bat", "shortcut.lnk", "site.url", "script.ps1", "help.chm",
+        "tool.jar", "script.py", "Install.command", "install.sh", "launcher.desktop", "Printer.AppImage",
+        // Documents that can carry macros or scripts.
+        "BOM.xls", "BOM.xlsm", "guide.doc", "guide.docm", "sheet.ods", "page.html", "logo.svg", "bundle.zip",
+        // No extension, an unknown one, or a name the desktop would read differently.
+        "readme", "pdf", "data.xyz", "", "...", "Manual.pdf.", "Manual.pdf ", "setup.exe:note.txt", "dir.pdf/readme");
+    INFO(unsafe);
+    CHECK_FALSE(is_safe_to_open_file_name(unsafe));
+}