argv.c

 
#include <winpr/config.h>
 
#include <winpr/crt.h>
#include <winpr/handle.h>
 
#include <winpr/thread.h>
 
#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#include "../log.h"
#define TAG WINPR_TAG("thread")
 
LPSTR* CommandLineToArgvA(LPCSTR lpCmdLine, int* pNumArgs)
{
  const char* p = NULL;
  size_t length = 0;
  const char* pBeg = NULL;
  const char* pEnd = NULL;
  char* buffer = NULL;
  char* pOutput = NULL;
  int numArgs = 0;
  LPSTR* pArgs = NULL;
  size_t maxNumArgs = 0;
  size_t maxBufferSize = 0;
  size_t cmdLineLength = 0;
  BOOL* lpEscapedChars = NULL;
  LPSTR lpEscapedCmdLine = NULL;
 
  if (!lpCmdLine)
    return NULL;
 
  if (!pNumArgs)
    return NULL;
 
  pArgs = NULL;
  lpEscapedCmdLine = NULL;
  cmdLineLength = strlen(lpCmdLine);
  lpEscapedChars = (BOOL*)calloc(cmdLineLength + 1, sizeof(BOOL));
 
  if (!lpEscapedChars)
    return NULL;
 
  if (strstr(lpCmdLine, "\\\""))
  {
    size_t n = 0;
    const char* pLastEnd = NULL;
    lpEscapedCmdLine = (char*)calloc(cmdLineLength + 1, sizeof(char));
 
    if (!lpEscapedCmdLine)
    {
      free(lpEscapedChars);
      return NULL;
    }
 
    p = (const char*)lpCmdLine;
    pLastEnd = (const char*)lpCmdLine;
    pOutput = (char*)lpEscapedCmdLine;
 
    while (p < &lpCmdLine[cmdLineLength])
    {
      pBeg = strstr(p, "\\\"");
 
      if (!pBeg)
      {
        length = strlen(p);
        CopyMemory(pOutput, p, length);
        pOutput += length;
        break;
      }
 
      pEnd = pBeg + 2;
 
      while (pBeg >= lpCmdLine)
      {
        if (*pBeg != '\\')
        {
          pBeg++;
          break;
        }
 
        pBeg--;
      }
 
      n = WINPR_ASSERTING_INT_CAST(size_t, ((pEnd - pBeg) - 1));
      length = WINPR_ASSERTING_INT_CAST(size_t, (pBeg - pLastEnd));
      CopyMemory(pOutput, p, length);
      pOutput += length;
      p += length;
 
      for (size_t i = 0; i < (n / 2); i++)
        *pOutput++ = '\\';
 
      p += n + 1;
 
      if ((n % 2) != 0)
        lpEscapedChars[pOutput - lpEscapedCmdLine] = TRUE;
 
      *pOutput++ = '"';
      pLastEnd = p;
    }
 
    *pOutput++ = '\0';
    lpCmdLine = (LPCSTR)lpEscapedCmdLine;
    cmdLineLength = strlen(lpCmdLine);
  }
 
  maxNumArgs = 2;
  p = (const char*)lpCmdLine;
 
  while (p < lpCmdLine + cmdLineLength)
  {
    p += strcspn(p, " \t");
    p += strspn(p, " \t");
    maxNumArgs++;
  }
 
  maxBufferSize = (maxNumArgs * (sizeof(char*))) + (cmdLineLength + 1);
  buffer = calloc(maxBufferSize, sizeof(char));
 
  if (!buffer)
  {
    free(lpEscapedCmdLine);
    free(lpEscapedChars);
    return NULL;
  }
 
  pArgs = (LPSTR*)buffer;
  pOutput = &buffer[maxNumArgs * (sizeof(char*))];
  p = (const char*)lpCmdLine;
 
  while (p < lpCmdLine + cmdLineLength)
  {
    pBeg = p;
 
    while (1)
    {
      p += strcspn(p, " \t\"\0");
 
      if ((*p != '"') || !lpEscapedChars[p - lpCmdLine])
        break;
 
      p++;
    }
 
    if (*p != '"')
    {
      /* no whitespace escaped with double quotes */
      length = WINPR_ASSERTING_INT_CAST(size_t, (p - pBeg));
      CopyMemory(pOutput, pBeg, length);
      pOutput[length] = '\0';
      pArgs[numArgs++] = pOutput;
      pOutput += (length + 1);
    }
    else
    {
      p++;
 
      while (1)
      {
        p += strcspn(p, "\"\0");
 
        if ((*p != '"') || !lpEscapedChars[p - lpCmdLine])
          break;
 
        p++;
      }
 
      if (*p != '"')
        WLog_ERR(TAG, "parsing error: uneven number of unescaped double quotes!");
 
      if (p[0] && p[1])
        p += 1 + strcspn(&p[1], " \t\0");
 
      pArgs[numArgs++] = pOutput;
 
      while (pBeg < p)
      {
        if (*pBeg != '"')
          *pOutput++ = *pBeg;
 
        pBeg++;
      }
 
      *pOutput++ = '\0';
    }
 
    p += strspn(p, " \t");
  }
 
  free(lpEscapedCmdLine);
  free(lpEscapedChars);
  *pNumArgs = numArgs;
  return pArgs;
}
 
#ifndef _WIN32
 
LPWSTR* CommandLineToArgvW(WINPR_ATTR_UNUSED LPCWSTR lpCmdLine, WINPR_ATTR_UNUSED int* pNumArgs)
{
  WLog_ERR("TODO", "TODO: Implement");
  return NULL;
}
 
#endif