mkshelllink.c File Reference

#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdint.h>

Include dependency graph for mkshelllink.c:

Go to the source code of this file.

Classes
struct	_GUID
struct	_FILETIME
struct	_LNK_HEADER
struct	_LNK_LOCATOR_INFO
struct	_LNK_LOCAL_VOLUME_INFO
struct	_ID_LIST_GUID
struct	_ID_LIST_DRIVE
struct	_ID_LIST_FILE
struct	_EXP_SPECIAL_FOLDER
struct	_EXP_SZ_LINK
struct	SPECIALFOLDER

Macros
#define	C_ASSERT(expr)   extern char (*c_assert(void)) [(expr) ? 1 : -1]
#define	__cdecl
#define	_countof(_Array)   (sizeof(_Array) / sizeof(_Array[0]))
#define	min(a, b)   (((a) < (b)) ? (a) : (b))
#define	SW_SHOWNORMAL   1
#define	SW_SHOWMINNOACTIVE   7
#define	DEFINE_GUID2(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)   const GUID name = { l,w1,w2,{ b1,b2,b3,b4,b5,b6,b7,b8 } }
#define	LOCATOR_LOCAL   0x1
#define	LOCATOR_NETWORK   0x2
#define	SLDF_DEFAULT   0x00000000
#define	SLDF_HAS_ID_LIST   0x00000001
#define	SLDF_HAS_LINK_INFO   0x00000002
#define	SLDF_HAS_NAME   0x00000004
#define	SLDF_HAS_RELPATH   0x00000008
#define	SLDF_HAS_WORKINGDIR   0x00000010
#define	SLDF_HAS_ARGS   0x00000020
#define	SLDF_HAS_ICONLOCATION   0x00000040
#define	SLDF_UNICODE   0x00000080
#define	SLDF_HAS_EXP_SZ   0x00000200
#define	SLDF_HAS_EXP_ICON_SZ   0x00004000
#define	LINK_ID_LIST   SLDF_HAS_ID_LIST
#define	LINK_FILE   SLDF_HAS_LINK_INFO
#define	LINK_DESCRIPTION   SLDF_HAS_NAME
#define	LINK_RELATIVE_PATH   SLDF_HAS_RELPATH
#define	LINK_WORKING_DIR   SLDF_HAS_WORKINGDIR
#define	LINK_CMDLINE_ARGS   SLDF_HAS_ARGS
#define	LINK_ICON   SLDF_HAS_ICONLOCATION
#define	LINK_UNICODE   SLDF_UNICODE
#define	PT_GUID   0x1F
#define	PT_DRIVE1   0x2F
#define	PT_FOLDER   0x31
#define	PT_VALUE   0x32
#define	REGITEMORDER_DEFAULT   0x80
#define	REGITEMORDER_LIBRARIES   0x42
#define	REGITEMORDER_USERSFILEFOLDER   0x44
#define	REGITEMORDER_MYCOMPUTER   0x50
#define	EXP_SPECIAL_FOLDER_SIG   0xA0000005
#define	MAX_PATH   260
#define	EXP_SZ_LINK_SIG   0xA0000001
#define	EXP_SZ_ICON_SIG   0xA0000007
#define	CSIDL_WINDOWS   0x24
#define	CSIDL_SYSTEM   0x25
#define	mbstowcs   my_mbstowcs

Typedefs
typedef struct _GUID	GUID
typedef struct _FILETIME	FILETIME
typedef struct _FILETIME *	PFILETIME
typedef struct _LNK_HEADER	LNK_HEADER
typedef struct _LNK_LOCATOR_INFO	LNK_LOCATOR_INFO
typedef struct _LNK_LOCAL_VOLUME_INFO	LNK_LOCAL_VOLUME_INFO
typedef struct _ID_LIST_GUID	ID_LIST_GUID
typedef struct _ID_LIST_DRIVE	ID_LIST_DRIVE
typedef struct _ID_LIST_FILE	ID_LIST_FILE
typedef struct _EXP_SPECIAL_FOLDER	EXP_SPECIAL_FOLDER
typedef struct _EXP_SZ_LINK	EXP_SZ_LINK

Functions
	C_ASSERT (sizeof(wchar_t)==sizeof(uint16_t))
	C_ASSERT (sizeof(GUID)==16)
	DEFINE_GUID2 (CLSID_ShellLink, 0x00021401, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 0x46)
	DEFINE_GUID2 (CLSID_MyComputer, 0x20D04FE0, 0x3AEA, 0x1069, 0xA2, 0xD8, 0x08, 0x00, 0x2B, 0x30, 0x30, 0x9D)
size_t	my_mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count)
static void __cdecl	trace (const char *format,...)
static bool	is_path_separator (char c)
static bool	has_env_variables (const char *str)
static void	strip_quotes_and_unescape_envvars (char **pstr)
static const struct SPECIALFOLDER *	get_special_folder (const char *target)
static void	write_string (FILE *pFile, bool bUnicode, const char *str)
int	main (int argc, const char *argv[])

Variables
static bool	g_Verbose = false
static const struct SPECIALFOLDER	g_specialfolders []

Macro Definition Documentation

__cdecl

#define __cdecl

Definition at line 25 of file mkshelllink.c.

_countof

#define _countof

(

_Array

)

(sizeof(_Array) / sizeof(_Array[0]))

Definition at line 40 of file mkshelllink.c.

C_ASSERT

#define C_ASSERT

(

expr

)

extern char (*c_assert(void)) [(expr) ? 1 : -1]

Definition at line 20 of file mkshelllink.c.

CSIDL_SYSTEM

#define CSIDL_SYSTEM   0x25

Definition at line 226 of file mkshelllink.c.

CSIDL_WINDOWS

#define CSIDL_WINDOWS   0x24

Definition at line 225 of file mkshelllink.c.

DEFINE_GUID2

#define DEFINE_GUID2	(		name,
			l,
			w1,
			w2,
			b1,
			b2,
			b3,
			b4,
			b5,
			b6,
			b7,
			b8
	)		const GUID name = { l,w1,w2,{ b1,b2,b3,b4,b5,b6,b7,b8 } }

Definition at line 71 of file mkshelllink.c.

EXP_SPECIAL_FOLDER_SIG

#define EXP_SPECIAL_FOLDER_SIG   0xA0000005

Definition at line 196 of file mkshelllink.c.

EXP_SZ_ICON_SIG

#define EXP_SZ_ICON_SIG   0xA0000007

Definition at line 208 of file mkshelllink.c.

EXP_SZ_LINK_SIG

#define EXP_SZ_LINK_SIG   0xA0000001

Definition at line 207 of file mkshelllink.c.

LINK_CMDLINE_ARGS

#define LINK_CMDLINE_ARGS   SLDF_HAS_ARGS

Definition at line 105 of file mkshelllink.c.

LINK_DESCRIPTION

#define LINK_DESCRIPTION   SLDF_HAS_NAME

Definition at line 102 of file mkshelllink.c.

LINK_FILE

#define LINK_FILE   SLDF_HAS_LINK_INFO

Definition at line 101 of file mkshelllink.c.

LINK_ICON

#define LINK_ICON   SLDF_HAS_ICONLOCATION

Definition at line 106 of file mkshelllink.c.

LINK_ID_LIST

#define LINK_ID_LIST   SLDF_HAS_ID_LIST

Definition at line 100 of file mkshelllink.c.

LINK_RELATIVE_PATH

#define LINK_RELATIVE_PATH   SLDF_HAS_RELPATH

Definition at line 103 of file mkshelllink.c.

LINK_UNICODE

#define LINK_UNICODE   SLDF_UNICODE

Definition at line 107 of file mkshelllink.c.

LINK_WORKING_DIR

#define LINK_WORKING_DIR   SLDF_HAS_WORKINGDIR

Definition at line 104 of file mkshelllink.c.

LOCATOR_LOCAL

#define LOCATOR_LOCAL   0x1

Definition at line 75 of file mkshelllink.c.

LOCATOR_NETWORK

#define LOCATOR_NETWORK   0x2

Definition at line 76 of file mkshelllink.c.

MAX_PATH

#define MAX_PATH   260

Definition at line 205 of file mkshelllink.c.

mbstowcs

#define mbstowcs   my_mbstowcs

Definition at line 272 of file mkshelllink.c.

min

#define min	(		a,
			b
	)		(((a) < (b)) ? (a) : (b))

Definition at line 43 of file mkshelllink.c.

PT_DRIVE1

#define PT_DRIVE1   0x2F

Definition at line 153 of file mkshelllink.c.

PT_FOLDER

#define PT_FOLDER   0x31

Definition at line 154 of file mkshelllink.c.

PT_GUID

#define PT_GUID   0x1F

Definition at line 152 of file mkshelllink.c.

PT_VALUE

#define PT_VALUE   0x32

Definition at line 155 of file mkshelllink.c.

REGITEMORDER_DEFAULT

#define REGITEMORDER_DEFAULT   0x80

Definition at line 158 of file mkshelllink.c.

REGITEMORDER_LIBRARIES

#define REGITEMORDER_LIBRARIES   0x42

Definition at line 159 of file mkshelllink.c.

REGITEMORDER_MYCOMPUTER

#define REGITEMORDER_MYCOMPUTER   0x50

Definition at line 161 of file mkshelllink.c.

REGITEMORDER_USERSFILEFOLDER

#define REGITEMORDER_USERSFILEFOLDER   0x44

Definition at line 160 of file mkshelllink.c.

SLDF_DEFAULT

#define SLDF_DEFAULT   0x00000000

Definition at line 88 of file mkshelllink.c.

SLDF_HAS_ARGS

#define SLDF_HAS_ARGS   0x00000020

Definition at line 94 of file mkshelllink.c.

SLDF_HAS_EXP_ICON_SZ

#define SLDF_HAS_EXP_ICON_SZ   0x00004000

Definition at line 98 of file mkshelllink.c.

SLDF_HAS_EXP_SZ

#define SLDF_HAS_EXP_SZ   0x00000200

Definition at line 97 of file mkshelllink.c.

SLDF_HAS_ICONLOCATION

#define SLDF_HAS_ICONLOCATION   0x00000040

Definition at line 95 of file mkshelllink.c.

SLDF_HAS_ID_LIST

#define SLDF_HAS_ID_LIST   0x00000001

Definition at line 89 of file mkshelllink.c.

SLDF_HAS_LINK_INFO

#define SLDF_HAS_LINK_INFO   0x00000002

Definition at line 90 of file mkshelllink.c.

SLDF_HAS_NAME

#define SLDF_HAS_NAME   0x00000004

Definition at line 91 of file mkshelllink.c.

SLDF_HAS_RELPATH

#define SLDF_HAS_RELPATH   0x00000008

Definition at line 92 of file mkshelllink.c.

SLDF_HAS_WORKINGDIR

#define SLDF_HAS_WORKINGDIR   0x00000010

Definition at line 93 of file mkshelllink.c.

SLDF_UNICODE

#define SLDF_UNICODE   0x00000080

Definition at line 96 of file mkshelllink.c.

SW_SHOWMINNOACTIVE

#define SW_SHOWMINNOACTIVE   7

Definition at line 54 of file mkshelllink.c.

SW_SHOWNORMAL

#define SW_SHOWNORMAL   1

Definition at line 53 of file mkshelllink.c.

Typedef Documentation

EXP_SPECIAL_FOLDER

typedef struct _EXP_SPECIAL_FOLDER EXP_SPECIAL_FOLDER

EXP_SZ_LINK

typedef struct _EXP_SZ_LINK EXP_SZ_LINK

FILETIME

typedef struct _FILETIME FILETIME

GUID

typedef struct _GUID GUID

ID_LIST_DRIVE

typedef struct _ID_LIST_DRIVE ID_LIST_DRIVE

ID_LIST_FILE

typedef struct _ID_LIST_FILE ID_LIST_FILE

ID_LIST_GUID

typedef struct _ID_LIST_GUID ID_LIST_GUID

LNK_HEADER

typedef struct _LNK_HEADER LNK_HEADER

LNK_LOCAL_VOLUME_INFO

typedef struct _LNK_LOCAL_VOLUME_INFO LNK_LOCAL_VOLUME_INFO

LNK_LOCATOR_INFO

typedef struct _LNK_LOCATOR_INFO LNK_LOCATOR_INFO

PFILETIME

typedef struct _FILETIME * PFILETIME

Function Documentation

C_ASSERT() [1/2]

C_ASSERT

(

sizeof(GUID)

= =16

)

C_ASSERT() [2/2]

C_ASSERT

(

sizeof(wchar_t)

= =sizeof(uint16_t)

)

DEFINE_GUID2() [1/2]

DEFINE_GUID2	(	CLSID_MyComputer	,
		0x20D04FE0	,
		0x3AEA	,
		0x1069	,
		0xA2	,
		0xD8	,
		0x08	,
		0x00	,
		0x2B	,
		0x30	,
		0x30	,
		0x9D
	)

DEFINE_GUID2() [2/2]

DEFINE_GUID2	(	CLSID_ShellLink	,
		0x00021401	,
		0	,
		0	,
		0xC0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0x46
	)

get_special_folder()

static const struct SPECIALFOLDER * get_special_folder ( const char *  target )

static

Definition at line 335 of file mkshelllink.c.

{
    char buf[256];
 
    strncpy(buf, target, sizeof(buf));
    buf[sizeof("shell:") - 1] = '\0';
    if (strcasecmp("shell:", buf))
        return NULL;
 
    target += sizeof("shell:") - 1;
    for (unsigned long i = 0;; ++i)
    {
        unsigned long len;
        const struct SPECIALFOLDER *special = &g_specialfolders[i];
        if (!special->name)
            return NULL;
        len = strlen(special->name);
        strncpy(buf, target, sizeof(buf));
        buf[len] = '\0';
        if (!strcasecmp(special->name, buf) && (is_path_separator(target[len]) || !target[len]))
            return &g_specialfolders[i];
    }
}

Referenced by main().

has_env_variables()

static bool has_env_variables ( const char *  str )

static

Definition at line 293 of file mkshelllink.c.

{
    const char *ptr = strchr(str, '%');
    return (ptr && strchr(ptr + 1, '%'));
}

Referenced by main().

is_path_separator()

static bool is_path_separator ( char  c )

static

Definition at line 286 of file mkshelllink.c.

{
    return (c == '\\' || c == '/');
}

Referenced by get_special_folder(), and main().

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 384 of file mkshelllink.c.

{
    const char *pszOutputPath = "shortcut.lnk";
    const char *pszTarget = NULL;
    const char *pszDescription = NULL;
    const char *pszWorkingDir = NULL;
    const char *pszCmdLineArgs = NULL;
    const char *pszIcon = NULL;
    char targetpath[MAX_PATH];
    int32_t IconIndex = 0;
    GUID Guid = CLSID_MyComputer;
    bool bHelp = false, bUnicode = false, bMinimized = false;
    int i;
    FILE *pFile;
    LNK_HEADER Header;
    uint32_t dwTmp;
    const struct SPECIALFOLDER *special;
    EXP_SPECIAL_FOLDER CsidlBlock, *pCsidlBlock = NULL;
    EXP_SZ_LINK SzLinkBlock, *pSzLinkBlock = NULL;
    EXP_SZ_LINK SzIconBlock, *pSzIconBlock = NULL;
 
    /* Check for verbose mode in the command-line */
    for (i = 1; i < argc; ++i)
    {
        if ((argv[i][0] == '-' || argv[i][0] == '/') &&
            !strcmp(argv[i] + 1, "v"))
        {
            g_Verbose = true;
            break;
        }
    }
 
    /* Parse the command-line */
    for (i = 1; i < argc; ++i)
    {
        trace("argv[%d]: %s\n", i, argv[i]);
 
        if (argv[i][0] != '-' && argv[i][0] != '/')
            pszTarget = argv[i];
        else if (!strcmp(argv[i] + 1, "h"))
            bHelp = true;
        else if (!strcmp(argv[i] + 1, "v"))
            /* Verbose mode, separately handled above */;
        else if (!strcmp(argv[i] + 1, "o") && (i + 1 < argc))
        {
            ++i;
            trace("argv[%d]: %s\n", i, argv[i]);
            pszOutputPath = argv[i];
        }
        else if (!strcmp(argv[i] + 1, "u"))
            bUnicode = true;
        else if (!strcmp(argv[i] + 1, "d") && (i + 1 < argc))
        {
            ++i;
            trace("argv[%d]: %s\n", i, argv[i]);
            pszDescription = argv[i];
        }
        else if (!strcmp(argv[i] + 1, "w") && (i + 1 < argc))
        {
            ++i;
            trace("argv[%d]: %s\n", i, argv[i]);
            pszWorkingDir = argv[i];
        }
        else if (!strcmp(argv[i] + 1, "c") && (i + 1 < argc))
        {
            ++i;
            trace("argv[%d]: %s\n", i, argv[i]);
            pszCmdLineArgs = argv[i];
        }
        else if (!strcmp(argv[i] + 1, "i") && (i + 1 < argc))
        {
            ++i;
            trace("argv[%d]: %s\n", i, argv[i]);
            pszIcon = argv[i];
        }
        else if (!strcmp(argv[i] + 1, "m"))
            bMinimized = true;
        else if (!strcmp(argv[i] + 1, "g") && (i + 1 < argc))
        {
            unsigned Data4Tmp[8], j;
 
            ++i;
            trace("argv[%d]: %s\n", i, argv[i]);
            sscanf(argv[i], "{%8x-%4hx-%4hx-%2x%2x-%2x%2x%2x%2x%2x%2x}",
                   &Guid.Data1, &Guid.Data2, &Guid.Data3,
                   &Data4Tmp[0], &Data4Tmp[1], &Data4Tmp[2], &Data4Tmp[3],
                   &Data4Tmp[4], &Data4Tmp[5], &Data4Tmp[6], &Data4Tmp[7]);
            for (j = 0; j < 8; ++j)
                Guid.Data4[j] = (uint8_t)Data4Tmp[j];
        }
        else
        {
            printf("Invalid option: %s\n", argv[i]);
            bHelp = true;
        }
    }
    if (argc > 1)
        trace("\n");
 
    if (!pszTarget || bHelp)
    {
        printf("Usage: %s [-h][-v][-o path][-u][-d descr][-w path][-c cmdline_args][-i [icon_path[,nr]]][-g guid] target\n"
               "-h\tShows this help.\n"
               "-v\tEnables verbose mode for diagnostics.\n"
               "-o path\tSets the output path.\n"
               "-u\tCreates a Unicode-aware shortcut.\n"
               "-d descr\tSets the shortcut description.\n"
               "-w path\tSets the working directory for the executable.\n"
               "-c cmdline_args\tSets the command-line arguments passed to the program.\n"
               "-i [icon_path[,nr]]\tSets the icon path and optionally its index. If only an index is given (but no path), the target file is used instead.\n"
               "-m\tStart minimized.\n"
               "-g guid\tSets the GUID to which the target path is relative. Default value is MyComputer GUID.\n"
               "target\tAbsolute or relative to GUID specified with the -g option path.\n", argv[0]);
        return 0;
    }
 
    /* Process the parameters */
    if (pszTarget)
        strip_quotes_and_unescape_envvars((char**)&pszTarget);
    if (pszWorkingDir)
        strip_quotes_and_unescape_envvars((char**)&pszWorkingDir);
    if (pszCmdLineArgs)
        strip_quotes_and_unescape_envvars((char**)&pszCmdLineArgs);
    if (pszIcon)
    {
        char *ptr, *endptr;
 
        strip_quotes_and_unescape_envvars((char**)&pszIcon);
 
        /* Check whether only an icon index was given */
        dwTmp = strtol(pszIcon, &endptr, 0);
        if (endptr && endptr != pszIcon)
        {
            /* Only an index was given; save it, and use the target as the icon file */
            IconIndex = dwTmp;
            pszIcon = (char*)1; // Canary value to tell to use pszTarget, once resolved.
        }
        else
        {
            /* No index was given: this is a file path, optionally followed by the icon index */
            ptr = strrchr(pszIcon, ',');
            if (ptr) // && isdigit(ptr[1])
            {
                /* We may have an index that follows the icon path */
                dwTmp = strtol(ptr+1, &endptr, 0);
                if (endptr && endptr != (ptr+1))
                {
                    /* It's valid, retrieve it and truncate the string to where the icon path ends */
                    IconIndex = dwTmp;
                    *ptr = '\0';
                }
            }
            pszIcon = pszIcon;
        }
    }
 
    trace("OutputPath  = %s\n"
          "Target      = %s\n"
          "Description = %s\n"
          "WorkingDir  = %s\n"
          "CmdLineArgs = %s\n"
          "Icon        = %s (%d)\n\n",
          pszOutputPath, pszTarget, pszDescription,
          pszWorkingDir, pszCmdLineArgs,
          (pszIcon == (char*)1) ? pszTarget : pszIcon, IconIndex);
 
    pFile = fopen(pszOutputPath, "wb");
    if (!pFile)
    {
        printf("Failed to open %s\n", pszOutputPath);
        return -1;
    }
 
    /* Header */
    memset(&Header, 0, sizeof(Header));
    Header.Size = sizeof(Header);
    Header.Guid = CLSID_ShellLink;
    Header.Flags = LINK_ID_LIST;
    if (bUnicode)
        Header.Flags |= LINK_UNICODE;
    if (pszDescription)
        Header.Flags |= LINK_DESCRIPTION;
    if (pszWorkingDir)
        Header.Flags |= LINK_WORKING_DIR;
    if (pszCmdLineArgs)
        Header.Flags |= LINK_CMDLINE_ARGS;
    if (pszIcon)
        Header.Flags |= LINK_ICON;
    Header.IconIndex = IconIndex;
    Header.ShowCmd = (bMinimized ? SW_SHOWMINNOACTIVE : SW_SHOWNORMAL);
 
    /* Verify the target type before proceeding further */
    special = get_special_folder(pszTarget);
    if (special)
        Header.Flags |= LINK_ID_LIST; // Definitively needed in this case.
 
    /* Check whether the target path contains Win32 environment variables */
    if (has_env_variables(pszTarget))
    {
        Header.Flags |= SLDF_HAS_EXP_SZ;
        Header.Flags &= ~LINK_ID_LIST; // We cannot deal with PIDLs in this case.
    }
    if ((Header.Flags & LINK_ID_LIST) && special)
        Header.Flags &= ~LINK_RELATIVE_PATH;
 
    /* If it's not a direct target, check whether it uses a special
     * folder that is defined using Win32 environment variables */
    if (special && special->unexpPath && has_env_variables(special->unexpPath))
        Header.Flags |= SLDF_HAS_EXP_SZ;
 
    /*
     * For the icon, first check the canary value that tells to use the target path.
     * If present, the icon path will contain Win32 environment variables if the target has them.
     * Otherwise, explicitly check whether the specified icon path contains environment variables.
     */
    if ((pszIcon == (char*)1) && (Header.Flags & SLDF_HAS_EXP_SZ))
        Header.Flags |= SLDF_HAS_EXP_ICON_SZ;
    else if (pszIcon && has_env_variables(pszIcon))
        Header.Flags |= SLDF_HAS_EXP_ICON_SZ;
 
    trace("Header.Flags     = 0x%08x\n"
          "Header.IconIndex = %d\n"
          "Header.ShowCmd   = %u\n",
          Header.Flags, Header.IconIndex, Header.ShowCmd);
 
    fwrite(&Header, sizeof(Header), 1, pFile);
 
    if (Header.Flags & LINK_ID_LIST)
    {
        ID_LIST_GUID IdListGuid;
        ID_LIST_DRIVE IdListDrive;
        ID_LIST_FILE IdListFile;
        unsigned int cbListSize = sizeof(IdListGuid) + sizeof(uint16_t);
        unsigned int cchName;
        const char *pszName;
        const char *pszOrgTarget = pszTarget;
        size_t specialPathLen = 0;
        uint16_t uhTmp;
 
        /* ID list. It appears explorer does not accept links
         * without an ID list. It is relative to desktop. */
        if (special)
        {
            CsidlBlock.cbSize = sizeof(CsidlBlock);
            CsidlBlock.dwSignature = EXP_SPECIAL_FOLDER_SIG;
            CsidlBlock.idSpecialFolder = special->csidl;
            specialPathLen = strlen(special->dummyPath);
            sprintf(targetpath, "%s\\%s", special->dummyPath, pszOrgTarget + sizeof("shell:") + strlen(special->name));
            pszTarget = targetpath;
        }
        pszName = pszTarget;
 
        if (pszName[0] && pszName[0] != ':' && pszName[1] == ':')
        {
            cbListSize += sizeof(IdListDrive);
            pszName += 2;
            while (is_path_separator(*pszName))
                ++pszName;
        }
 
        while (*pszName)
        {
            cchName = 0;
            while (pszName[cchName] && !is_path_separator(pszName[cchName]))
                ++cchName;
 
            if (cchName != 1 || pszName[0] != '.')
            {
                /* Don't care about the DOS name */
                //cbListSize += sizeof(IdListFile) + 2 * (cchName + 1);
                cbListSize += sizeof(IdListFile) + (cchName + 1) + 1;
            }
 
            if (special && ((pszName+cchName)-pszTarget == specialPathLen))
            {
                /* Point the special folder block to the rest of the path in the ID list */
                CsidlBlock.cbOffset = cbListSize - sizeof(uint16_t);
                pCsidlBlock = &CsidlBlock;
            }
 
            pszName += cchName;
            while (is_path_separator(*pszName))
                ++pszName;
        }
 
        /* ID list size */
        uhTmp = cbListSize;
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
 
        IdListGuid.Size = sizeof(IdListGuid);
        IdListGuid.Type = PT_GUID;
        IdListGuid.uSortOrder = REGITEMORDER_MYCOMPUTER;
        IdListGuid.guid = Guid;
        fwrite(&IdListGuid, sizeof(IdListGuid), 1, pFile);
 
        pszName = pszTarget;
 
        if (isalpha(pszName[0]) && pszName[1] == ':')
        {
            memset(&IdListDrive, 0, sizeof(IdListDrive));
            IdListDrive.Size = sizeof(IdListDrive);
            IdListDrive.Type = PT_DRIVE1;
            sprintf(IdListDrive.szDriveName, "%c:\\", pszName[0]);
            fwrite(&IdListDrive, sizeof(IdListDrive), 1, pFile);
            pszName += 2;
            while (is_path_separator(*pszName))
                ++pszName;
        }
 
        while (*pszName)
        {
            cchName = 0;
            while (pszName[cchName] && !is_path_separator(pszName[cchName]))
                ++cchName;
 
            if (cchName != 1 || pszName[0] != '.')
            {
                memset(&IdListFile, 0, sizeof(IdListFile));
                /* Don't care about the DOS name */
                //IdListFile.Size = sizeof(IdListFile) + 2 * (cchName + 1);
                IdListFile.Size = sizeof(IdListFile) + (cchName + 1) + 1;
                if (!pszName[cchName])
                    IdListFile.Type = PT_VALUE; // File
                else
                    IdListFile.Type = PT_FOLDER;
                fwrite(&IdListFile, sizeof(IdListFile), 1, pFile);
                fwrite(pszName, cchName, 1, pFile);
                fputc(0, pFile); // NUL-terminate
                /* Don't care about the DOS name */
                //fwrite(pszName, cchName, 1, pFile);
                fputc(0, pFile); // NUL-terminate
            }
 
            pszName += cchName;
            while (is_path_separator(*pszName))
                ++pszName;
        }
 
        /* End of ID list */
        uhTmp = 0;
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
 
        /* Reset the target path to the actual unexpanded path */
        if (special)
        {
            sprintf(targetpath, "%s\\%s", special->unexpPath, pszOrgTarget + sizeof("shell:") + strlen(special->name));
            pszTarget = targetpath;
        }
    }
 
    /* Now, set the icon path to the target path if it has the specific canary value */
    if (pszIcon == (char*)1)
        pszIcon = pszTarget;
 
    if (Header.Flags & SLDF_HAS_EXP_SZ)
    {
        memset(&SzLinkBlock, 0, sizeof(SzLinkBlock));
        SzLinkBlock.cbSize = sizeof(SzLinkBlock);
        SzLinkBlock.dwSignature = EXP_SZ_LINK_SIG;
 
        /* We have to store both ANSI and UTF16 versions of the string! */
        strncpy(SzLinkBlock.szTarget, pszTarget, _countof(SzLinkBlock.szTarget));
        mbstowcs(SzLinkBlock.szwTarget, pszTarget, _countof(SzLinkBlock.szwTarget));
 
        pSzLinkBlock = &SzLinkBlock;
    }
 
    if (Header.Flags & SLDF_HAS_EXP_ICON_SZ)
    {
        memset(&SzIconBlock, 0, sizeof(SzIconBlock));
        SzIconBlock.cbSize = sizeof(SzIconBlock);
        SzIconBlock.dwSignature = EXP_SZ_ICON_SIG;
 
        /* We have to store both ANSI and UTF16 versions of the string! */
        strncpy(SzIconBlock.szTarget, pszIcon, _countof(SzIconBlock.szTarget));
        mbstowcs(SzIconBlock.szwTarget, pszIcon, _countof(SzIconBlock.szwTarget));
 
        pSzIconBlock = &SzIconBlock;
    }
 
    /* Description */
    if (Header.Flags & LINK_DESCRIPTION)
        write_string(pFile, bUnicode, pszDescription);
 
    /* Relative path */
    if (Header.Flags & LINK_RELATIVE_PATH)
        write_string(pFile, bUnicode, pszTarget);
 
    /* Working directory */
    if (Header.Flags & LINK_WORKING_DIR)
        write_string(pFile, bUnicode, pszWorkingDir);
 
    /* Command-line arguments */
    if (Header.Flags & LINK_CMDLINE_ARGS)
        write_string(pFile, bUnicode, pszCmdLineArgs);
 
    /* Icon path */
    if (Header.Flags & LINK_ICON)
        write_string(pFile, bUnicode, pszIcon);
 
    /* Write the data block list */
    if (pCsidlBlock)
        fwrite(pCsidlBlock, sizeof(*pCsidlBlock), 1, pFile);
    if (pSzLinkBlock)
        fwrite(pSzLinkBlock, sizeof(*pSzLinkBlock), 1, pFile);
    if (pSzIconBlock)
        fwrite(pSzIconBlock, sizeof(*pSzIconBlock), 1, pFile);
    /* End of data block list */
    dwTmp = 0;
    fwrite(&dwTmp, sizeof(dwTmp), 1, pFile);
 
    fclose(pFile);
 
    return 0;
}

my_mbstowcs()

size_t my_mbstowcs	(	wchar_t *	wcstr,
		const char *	mbstr,
		size_t	count
	)

Definition at line 249 of file mkshelllink.c.

{
    size_t i;
    size_t len = strlen(mbstr) + 1; // Count the NUL-terminator.
 
    /* Convert up to the NUL-terminator (included) and at most 'count' characters */
    count = min(count, len);
 
    /* POSIX extension: if wcstr is NULL, return the number of wide
     * characters that would be written to wcstr, if converted. */
    if (!wcstr)
        return count;
 
    if (count == 0)
        return (size_t)0; // dest string exists, but 0 bytes converted.
    for (i = 0; i < count; ++i)
        wcstr[i] = (wchar_t)mbstr[i];
    /* Return the number of wide characters, excluding the NUL-terminator, written to wcstr */
    return (i - 1);
}

strip_quotes_and_unescape_envvars()

static void strip_quotes_and_unescape_envvars ( char **  pstr )

static

Definition at line 299 of file mkshelllink.c.

{
    char *str = *pstr;
    char *ptr, *dst;
 
    /* Skip leading spaces */
    while (isspace(*str))
        ++str;
 
    /* Strip trailing spaces */
    ptr = str + strlen(str);
    while ((ptr > str) && isspace(*(ptr-1)))
        --ptr;
    *ptr = '\0';
 
    /* If quoted, skip the leading and strip the trailing quotes */
    if ((ptr > str + 1) && (*str == '"') && (*(ptr-1) == '"'))
    {
        ++str;
        *(--ptr) = '\0';
    }
 
    /* Un-escape the '^%' in environment variables names */
    for (dst = ptr = str; *ptr; ++ptr, ++dst)
    {
        if (*ptr == '^' && *(ptr+1) == '%')
            ++ptr;
        if (ptr > dst) // Copy characters as soon as source advances destination.
            *dst = *ptr;
    }
    *dst = '\0';
 
    /* Return the string */
    *pstr = str;
}

Referenced by main().

trace()

static void __cdecl trace ( const char *  format,   ...  )

static

Definition at line 274 of file mkshelllink.c.

{
    va_list args;
 
    if (!g_Verbose)
        return;
 
    va_start(args, format);
    vprintf(format, args);
    va_end(args);
}

write_string()

static void write_string ( FILE *  pFile, bool  bUnicode, const char *  str  )

static

Definition at line 363 of file mkshelllink.c.

{
    uint16_t uhTmp;
 
    /* String length in number of ANSI or Unicode characters */
    uhTmp = strlen(str);
    fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
 
    /* String data (ANSI or Unicode) */
    if (!bUnicode)
    {
        fwrite(str, uhTmp, 1, pFile);
    }
    else
    {
        wchar_t tmpBufferU[1024]; // Large-enough buffer for string conversions.
        uhTmp = (uint16_t)mbstowcs(tmpBufferU, str, _countof(tmpBufferU));
        fwrite(tmpBufferU, uhTmp * sizeof(wchar_t), 1, pFile);
    }
}

Referenced by main().

Variable Documentation

g_specialfolders

const struct SPECIALFOLDER g_specialfolders[]

static

Initial value:

= {
    { CSIDL_WINDOWS, "windows", "X:\\reactos", "%SystemRoot%" },
    { CSIDL_SYSTEM,  "system",  "X:\\reactos\\system32", "%SystemRoot%\\system32" },
    { 0, NULL, NULL, NULL }
}

Referenced by get_special_folder().

g_Verbose

bool g_Verbose = false

static

Definition at line 222 of file mkshelllink.c.

Referenced by main(), and trace().