Return to cmdline.c CVS log

Up to [truecrypt] / truecrypt / common

Annotation of truecrypt/common/cmdline.c, revision 1.1

1.1     ! root        1: /* Copyright (C) 2004 TrueCrypt Team, truecrypt.org
        !             2:    This product uses components written by Paul Le Roux <[email protected]> */
        !             3: 
        !             4: #include "TCdefs.h"
        !             5: 
        !             6: #include <malloc.h>
        !             7: #include <ctype.h>
        !             8: #include "cmdline.h"
        !             9: 
        !            10: #include "resource.h"
        !            11: #include "crypto.h"
        !            12: #include "apidrvr.h"
        !            13: #include "dlgcode.h"
        !            14: 
        !            15: /* Except in response to the WM_INITDIALOG message, the dialog box procedure
        !            16:    should return nonzero if it processes the message, and zero if it does
        !            17:    not. - see DialogProc */
        !            18: BOOL WINAPI
        !            19: CommandHelpDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
        !            20: {
        !            21:        if (lParam);            /* remove warning */
        !            22:        if (wParam);            /* remove warning */
        !            23: 
        !            24:        switch (msg)
        !            25:        {
        !            26:        case WM_INITDIALOG:
        !            27:                {
        !            28:                char * tmp = err_malloc(8192);
        !            29:                char tmp2[256];
        !            30:                argumentspec *as;
        !            31:                int i;
        !            32: 
        !            33:                SetDefaultUserFont (hwndDlg);
        !            34: 
        !            35:                as = (argumentspec*) lParam;
        !            36: 
        !            37:                *tmp = 0;
        !            38: 
        !            39:                for (i = 0; i < as->arg_cnt; i ++)
        !            40:                {
        !            41:                        sprintf(tmp2, "%s       %s\n", as->args[i].long_name, 
        !            42:                                        as->args[i].short_name);
        !            43:                        strcat(tmp,tmp2);
        !            44:                }
        !            45: 
        !            46:                SetWindowText (GetDlgItem (hwndDlg, IDC_COMMANDHELP_TEXT), (char*) tmp);
        !            47:                return 1;
        !            48:                }
        !            49: 
        !            50:        case WM_COMMAND:
        !            51:                EndDialog (hwndDlg, IDOK);
        !            52:                return 1;
        !            53:        case WM_CLOSE:
        !            54:                EndDialog (hwndDlg, 0);
        !            55:                return 1;
        !            56:        }
        !            57: 
        !            58:        return 0;
        !            59: }
        !            60: 
        !            61: int
        !            62: Win32CommandLine (char *lpszCommandLine, char ***lpszArgs)
        !            63: {
        !            64:        int i = 0, k = 0, x = 0, nValid = TRUE;
        !            65:        int nLen = strlen (lpszCommandLine);
        !            66:        int nArrSize = 16;
        !            67:        char szTmp[256];
        !            68: 
        !            69:        *lpszArgs = malloc (sizeof (char *)* nArrSize);
        !            70: 
        !            71:        if (*lpszArgs == NULL)
        !            72:                return 0;
        !            73: 
        !            74:        while (i < nLen)
        !            75:        {
        !            76:                if (lpszCommandLine[i] == ' ')
        !            77:                {
        !            78:                        if (k > 0)
        !            79:                        {
        !            80:                                szTmp[k] = 0;
        !            81:                                (*lpszArgs)[x] = _strdup (szTmp);
        !            82:                                if ((*lpszArgs)[x] == NULL)
        !            83:                                {
        !            84:                                        free (*lpszArgs);
        !            85:                                        return 0;
        !            86:                                }
        !            87:                                x++;
        !            88:                                k = 0;
        !            89:                                if (x == nArrSize)
        !            90:                                {
        !            91:                                        break;
        !            92:                                }
        !            93:                        }
        !            94:                        i++;
        !            95:                        continue;
        !            96:                }
        !            97:                if (lpszCommandLine[i] == '"')
        !            98:                {
        !            99:                        i++;
        !           100:                        while (i < nLen)
        !           101:                        {
        !           102:                                if (lpszCommandLine[i] == '"')
        !           103:                                        break;
        !           104:                                if (k < sizeof (szTmp))
        !           105:                                        szTmp[k++] = lpszCommandLine[i++];
        !           106:                                else
        !           107:                                {
        !           108:                                        free (*lpszArgs);
        !           109:                                        return 0;
        !           110:                                }
        !           111:                        }
        !           112: 
        !           113:                        if (lpszCommandLine[i] != '"')
        !           114:                        {
        !           115:                                nValid = FALSE;
        !           116:                                break;
        !           117:                        }
        !           118:                }
        !           119:                else
        !           120:                {
        !           121:                        if (k < sizeof (szTmp))
        !           122:                                szTmp[k++] = lpszCommandLine[i];
        !           123:                        else
        !           124:                        {
        !           125:                                free (*lpszArgs);
        !           126:                                return 0;
        !           127:                        }
        !           128:                }
        !           129: 
        !           130:                i++;
        !           131:        }
        !           132: 
        !           133:        if (nValid == FALSE)
        !           134:        {
        !           135:                free (*lpszArgs);
        !           136:                return 0;
        !           137:        }
        !           138:        else if (k > 0)
        !           139:        {
        !           140:                szTmp[k] = 0;
        !           141:                (*lpszArgs)[x] = _strdup (szTmp);
        !           142:                if ((*lpszArgs)[x] == NULL)
        !           143:                {
        !           144:                        free (*lpszArgs);
        !           145:                        return 0;
        !           146:                }
        !           147:                x++;
        !           148:                k = 0;
        !           149:        }
        !           150:        if (!x)
        !           151:        {
        !           152:                free (*lpszArgs);
        !           153:                return 0;
        !           154:        }
        !           155:        return x;
        !           156: }
        !           157: 
        !           158: int
        !           159: GetArgSepPosOffset (char *lpszArgument)
        !           160: {
        !           161:        if (lpszArgument[0] == '/')
        !           162:                return 1;
        !           163:        else if (lpszArgument[0] == '-' && lpszArgument[1] == '-')
        !           164:                return 2;
        !           165:        else if (lpszArgument[0] == '-')
        !           166:                return 1;
        !           167:        else
        !           168:                return 0;
        !           169: }
        !           170: 
        !           171: int
        !           172: GetArgumentID (argumentspec *as, char *lpszArgument, int *nArgPos)
        !           173: {
        !           174:        char szTmp[256];
        !           175:        int i;
        !           176: 
        !           177:        i = strlen (lpszArgument);
        !           178:        szTmp[i] = 0;
        !           179:        while (--i >= 0)
        !           180:        {
        !           181:                szTmp[i] = (char) tolower (lpszArgument[i]);
        !           182:        }
        !           183: 
        !           184:        for (i = 0; i < as->arg_cnt; i++)
        !           185:        {
        !           186:                size_t k;
        !           187: 
        !           188:                k = strlen (as->args[i].long_name);
        !           189:                if (memcmp (as->args[i].long_name, szTmp, k * sizeof (char)) == 0)
        !           190:                {
        !           191:                        int x;
        !           192:                        for (x = i + 1; x < as->arg_cnt; x++)
        !           193:                        {
        !           194:                                size_t m;
        !           195: 
        !           196:                                m = strlen (as->args[x].long_name);
        !           197:                                if (memcmp (as->args[x].long_name, szTmp, m * sizeof (char)) == 0)
        !           198:                                {
        !           199:                                        break;
        !           200:                                }
        !           201:                        }
        !           202: 
        !           203:                        if (x == as->arg_cnt)
        !           204:                        {
        !           205:                                if (strlen (lpszArgument) != k)
        !           206:                                        *nArgPos = k;
        !           207:                                else
        !           208:                                        *nArgPos = 0;
        !           209:                                return as->args[i].short_name[1];
        !           210:                        }
        !           211:                }
        !           212:        }
        !           213: 
        !           214:        for (i = 0; i < as->arg_cnt; i++)
        !           215:        {
        !           216:                size_t k;
        !           217: 
        !           218:                k = strlen (as->args[i].short_name);
        !           219:                if (memcmp (as->args[i].short_name, szTmp, k * sizeof (char)) == 0)
        !           220:                {
        !           221:                        int x;
        !           222:                        for (x = i + 1; x < as->arg_cnt; x++)
        !           223:                        {
        !           224:                                size_t m;
        !           225: 
        !           226:                                m = strlen (as->args[x].short_name);
        !           227:                                if (memcmp (as->args[x].short_name, szTmp, m * sizeof (char)) == 0)
        !           228:                                {
        !           229:                                        break;
        !           230:                                }
        !           231:                        }
        !           232: 
        !           233:                        if (x == as->arg_cnt)
        !           234:                        {
        !           235:                                if (strlen (lpszArgument) != k)
        !           236:                                        *nArgPos = k;
        !           237:                                else
        !           238:                                        *nArgPos = 0;
        !           239:                                return as->args[i].short_name[1];
        !           240:                        }
        !           241:                }
        !           242:        }
        !           243: 
        !           244: 
        !           245:        return -1;
        !           246: }
        !           247: 
        !           248: int
        !           249: GetArgumentValue (char **lpszCommandLineArgs, int nArgPos, int *nArgIdx,
        !           250:                  int nNoCommandLineArgs, char *lpszValue, int nValueSize)
        !           251: {
        !           252:        *lpszValue = 0;
        !           253: 
        !           254:        if (nArgPos)
        !           255:        {
        !           256:                /* Handles the case of no space between parameter code and
        !           257:                   value */
        !           258:                memcpy (lpszValue, &lpszCommandLineArgs[*nArgIdx][nArgPos], nValueSize * sizeof (char));
        !           259:                lpszValue[nValueSize - 1] = 0;
        !           260:                return HAS_ARGUMENT;
        !           261:        }
        !           262:        else if (*nArgIdx + 1 != nNoCommandLineArgs)
        !           263:        {
        !           264:                int x = GetArgSepPosOffset (lpszCommandLineArgs[*nArgIdx + 1]);
        !           265:                if (x == 0)
        !           266:                {
        !           267:                        /* Handles the case of space between parameter code
        !           268:                           and value */
        !           269:                        memcpy (lpszValue, &lpszCommandLineArgs[*nArgIdx + 1][x], nValueSize * sizeof (char));
        !           270:                        lpszValue[nValueSize - 1] = 0;
        !           271:                        (*nArgIdx)++;
        !           272:                        return HAS_ARGUMENT;
        !           273:                }
        !           274:        }
        !           275: 
        !           276:        return HAS_NO_ARGUMENT;
        !           277: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.