mkshelllink.c File Reference

#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_FILE
struct	_ID_LIST_GUID
struct	_ID_LIST_DRIVE
struct	_EXP_SPECIAL_FOLDER
struct	SPECIALFOLDER

Macros
#define	SW_SHOWNORMAL   1
#define	SW_SHOWMINNOACTIVE   7
#define	CSIDL_WINDOWS   0x24
#define	CSIDL_SYSTEM   0x25
#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	LINK_ID_LIST   0x01
#define	LINK_FILE   0x02
#define	LINK_DESCRIPTION   0x04
#define	LINK_RELATIVE_PATH   0x08
#define	LINK_WORKING_DIR   0x10
#define	LINK_CMD_LINE_ARGS   0x20
#define	LINK_ICON   0x40
#define	LINK_UNICODE   0x80
#define	LOCATOR_LOCAL   0x1
#define	LOCATOR_NETWORK   0x2
#define	PT_GUID   0x1F
#define	PT_DRIVE1   0x2F
#define	PT_FOLDER   0x31
#define	PT_VALUE   0x32
#define	EXP_SPECIAL_FOLDER_SIG   0xA0000005

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_FILE	ID_LIST_FILE
typedef struct _ID_LIST_GUID	ID_LIST_GUID
typedef struct _ID_LIST_DRIVE	ID_LIST_DRIVE
typedef struct _EXP_SPECIAL_FOLDER	EXP_SPECIAL_FOLDER

Functions
	DEFINE_GUID2 (CLSID_ShellLink, 0x00021401L, 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)
static unsigned int	is_path_separator (unsigned int c)
static const struct SPECIALFOLDER *	get_special_folder (const char *target)
int	main (int argc, const char *argv[])

Variables
static const struct SPECIALFOLDER	g_specialfolders []

Macro Definition Documentation

CSIDL_SYSTEM

#define CSIDL_SYSTEM   0x25

Definition at line 28 of file mkshelllink.c.

CSIDL_WINDOWS

#define CSIDL_WINDOWS   0x24

Definition at line 27 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 43 of file mkshelllink.c.

EXP_SPECIAL_FOLDER_SIG

#define EXP_SPECIAL_FOLDER_SIG   0xA0000005

Definition at line 134 of file mkshelllink.c.

LINK_CMD_LINE_ARGS

#define LINK_CMD_LINE_ARGS   0x20

Definition at line 52 of file mkshelllink.c.

LINK_DESCRIPTION

#define LINK_DESCRIPTION   0x04

Definition at line 49 of file mkshelllink.c.

LINK_FILE

#define LINK_FILE   0x02

Definition at line 48 of file mkshelllink.c.

LINK_ICON

#define LINK_ICON   0x40

Definition at line 53 of file mkshelllink.c.

LINK_ID_LIST

#define LINK_ID_LIST   0x01

Definition at line 47 of file mkshelllink.c.

LINK_RELATIVE_PATH

#define LINK_RELATIVE_PATH   0x08

Definition at line 50 of file mkshelllink.c.

LINK_UNICODE

#define LINK_UNICODE   0x80

Definition at line 54 of file mkshelllink.c.

LINK_WORKING_DIR

#define LINK_WORKING_DIR   0x10

Definition at line 51 of file mkshelllink.c.

LOCATOR_LOCAL

#define LOCATOR_LOCAL   0x1

Definition at line 56 of file mkshelllink.c.

LOCATOR_NETWORK

#define LOCATOR_NETWORK   0x2

Definition at line 57 of file mkshelllink.c.

PT_DRIVE1

#define PT_DRIVE1   0x2F

Definition at line 102 of file mkshelllink.c.

PT_FOLDER

#define PT_FOLDER   0x31

Definition at line 103 of file mkshelllink.c.

PT_GUID

#define PT_GUID   0x1F

Definition at line 101 of file mkshelllink.c.

PT_VALUE

#define PT_VALUE   0x32

Definition at line 104 of file mkshelllink.c.

SW_SHOWMINNOACTIVE

#define SW_SHOWMINNOACTIVE   7

Definition at line 26 of file mkshelllink.c.

SW_SHOWNORMAL

#define SW_SHOWNORMAL   1

Definition at line 25 of file mkshelllink.c.

Typedef Documentation

EXP_SPECIAL_FOLDER

typedef struct _EXP_SPECIAL_FOLDER EXP_SPECIAL_FOLDER

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

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	,
		0x00021401L	,
		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 156 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().

is_path_separator()

static unsigned int is_path_separator ( unsigned int  c )

static

Definition at line 151 of file mkshelllink.c.

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

Referenced by get_special_folder().

main()

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

Definition at line 179 of file mkshelllink.c.

{
    int i;
    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[260];
    int IconNr = 0;
    GUID Guid = CLSID_MyComputer;
    int bHelp = 0, bMinimized = 0;
    FILE *pFile;
    LNK_HEADER Header;
    uint16_t uhTmp;
    uint32_t dwTmp;
    EXP_SPECIAL_FOLDER CsidlBlock, *pCsidlBlock = NULL;
 
    for (i = 1; i < argc; ++i)
    {
        if (argv[i][0] != '-' && argv[i][0] != '/')
            pszTarget = argv[i];
        else if (!strcmp(argv[i] + 1, "h"))
            bHelp = 1;
        else if (!strcmp(argv[i] + 1, "o") && i + 1 < argc)
            pszOutputPath = argv[++i];
        else if (!strcmp(argv[i] + 1, "d") && i + 1 < argc)
            pszDescription = argv[++i];
        else if (!strcmp(argv[i] + 1, "w") && i + 1 < argc)
            pszWorkingDir = argv[++i];
        else if (!strcmp(argv[i] + 1, "c") && i + 1 < argc)
            pszCmdLineArgs = argv[++i];
        else if (!strcmp(argv[i] + 1, "i") && i + 1 < argc)
        {
            pszIcon = argv[++i];
            if (i + 1 < argc && isdigit(argv[i + 1][0]))
                IconNr = atoi(argv[++i]);
        }
        else if (!strcmp(argv[i] + 1, "m"))
            bMinimized = 1;
        else if (!strcmp(argv[i] + 1, "g") && i + 1 < argc)
        {
            unsigned Data4Tmp[8], j;
 
            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]);
    }
 
    if (!pszTarget || bHelp)
    {
        printf("Usage: %s [-o path][-d descr][-w path][-c cmd_line_args][-i icon_path [nr]][-h][-g guid] target\n"
               "-o path\tSets output path\n"
               "-d descr\tSets shortcut description\n"
               "-w path\tSets working directory for executable\n"
               "-c cmd_line_args\tSets command line arguments passed to program\n"
               "-i icon_path [nr]\tSets icon file and optionally icon index\n"
               "-m\tStart minimized\n"
               "-g guid\tSets GUID to which target path is relative. Default value is MyComputer GUID.\n"
               "target\tAbsolute or relative to guid specified with -g option path\n", argv[0]);
        return 0;
    }
 
    pFile = fopen(pszOutputPath, "wb");
    if (!pFile)
    {
        printf("Failed to open %s\n", pszOutputPath);
        return -1;
    }
 
    // Header
    memset(&Header, 0, sizeof(Header));
    Header.Signature = (uint32_t)'L';
    Header.Guid = CLSID_ShellLink;
    Header.Flags = LINK_ID_LIST;
    if (pszDescription)
        Header.Flags |= LINK_DESCRIPTION;
    if (pszWorkingDir)
        Header.Flags |= LINK_WORKING_DIR;
    if (pszCmdLineArgs)
        Header.Flags |= LINK_CMD_LINE_ARGS;
    if (pszIcon)
        Header.Flags |= LINK_ICON;
    Header.IconNr = IconNr;
    Header.Show = bMinimized ? SW_SHOWMINNOACTIVE : SW_SHOWNORMAL;
    fwrite(&Header, sizeof(Header), 1, pFile);
 
    if (Header.Flags & LINK_ID_LIST)
    {
        ID_LIST_FILE IdListFile;
        ID_LIST_GUID IdListGuid;
        ID_LIST_DRIVE IdListDrive;
        unsigned cbListSize = sizeof(IdListGuid) + sizeof(uint16_t), cchName;
        const char *pszName = pszTarget;
        int index = 1, specialindex = -1;
        const struct SPECIALFOLDER *special = get_special_folder(pszTarget);
 
        // ID list
        // It seems explorer does not accept links without id list. List is relative to desktop.
 
        if (special)
        {
            Header.Flags &= ~LINK_RELATIVE_PATH;
            CsidlBlock.cbSize = sizeof(CsidlBlock);
            CsidlBlock.dwSignature = EXP_SPECIAL_FOLDER_SIG;
            CsidlBlock.idSpecialFolder = special->csidl;
            specialindex = 3; // Skip GUID, drive and fake windows/reactos folder
            sprintf(targetpath, "x:\\reactos\\%s", pszTarget + sizeof("shell:") + strlen(special->name));
            pszName = pszTarget = targetpath;
        }
 
        if (pszName[0] && pszName[0] != ':' && pszName[1] == ':')
        {
            ++index;
            cbListSize += sizeof(IdListDrive);
            pszName += 2;
            while (*pszName == '\\' || *pszName == '/')
                ++pszName;
        }
 
        while (*pszName)
        {
            cchName = 0;
            while (pszName[cchName] && pszName[cchName] != '\\' && pszName[cchName] != '/')
                ++cchName;
 
            if (cchName != 1 || pszName[0] != '.')
                cbListSize += sizeof(IdListFile) + 2 * (cchName + 1);
 
            if (++index == specialindex)
            {
                CsidlBlock.cbOffset = cbListSize - sizeof(uint16_t);
                pCsidlBlock = &CsidlBlock;
            }
 
            pszName += cchName;
            while (*pszName == '\\' || *pszName == '/')
                ++pszName;
        }
 
        uhTmp = cbListSize;
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile); // size
 
        IdListGuid.Size = sizeof(IdListGuid);
        IdListGuid.Type = PT_GUID;
        IdListGuid.dummy = 0x50;
        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(*pszName == '\\' || *pszName == '/')
                ++pszName;
        }
 
        while (*pszName)
        {
            cchName = 0;
            while (pszName[cchName] && pszName[cchName] != '\\' && pszName[cchName] != '/')
                ++cchName;
 
            if (cchName != 1 || pszName[0] != '.')
            {
                memset(&IdListFile, 0, sizeof(IdListFile));
                IdListFile.Size = sizeof(IdListFile) + 2 * (cchName + 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);
                fwrite(pszName, cchName, 1, pFile);
                fputc(0, pFile);
            }
 
            pszName += cchName;
            while (*pszName == '\\' || *pszName == '/')
                ++pszName;
        }
 
        uhTmp = 0; // list end
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
    }
 
    if (Header.Flags & LINK_DESCRIPTION)
    {
        // Description
        uhTmp = strlen(pszDescription);
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
        fputs(pszDescription, pFile);
    }
 
    if (Header.Flags & LINK_RELATIVE_PATH)
    {
        // Relative Path
        uhTmp = strlen(pszTarget);
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
        fputs(pszTarget, pFile);
    }
 
    if (Header.Flags & LINK_WORKING_DIR)
    {
        // Working Dir
        uhTmp = strlen(pszWorkingDir);
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
        fputs(pszWorkingDir, pFile);
    }
 
    if (Header.Flags & LINK_CMD_LINE_ARGS)
    {
        // Command line arguments
        uhTmp = strlen(pszCmdLineArgs);
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
        fputs(pszCmdLineArgs, pFile);
    }
 
    if (Header.Flags & LINK_ICON)
    {
        // Command line arguments
        uhTmp = strlen(pszIcon);
        fwrite(&uhTmp, sizeof(uhTmp), 1, pFile);
        fputs(pszIcon, pFile);
    }
 
    // Extra stuff
    if (pCsidlBlock)
        fwrite(pCsidlBlock, sizeof(*pCsidlBlock), 1, pFile);
    dwTmp = 0;
    fwrite(&dwTmp, sizeof(dwTmp), 1, pFile);
 
    fclose(pFile);
 
    return 0;
}

Variable Documentation

g_specialfolders

const struct SPECIALFOLDER g_specialfolders[]

static

Initial value:

= {
    { CSIDL_WINDOWS, "windows" },
    { CSIDL_SYSTEM, "system" },
    { 0, NULL}
}

Referenced by get_special_folder().