TORUrlVars.cpp

From mr.sysel, 4 Years ago, written in C, viewed 529 times.
URL http://paste.security-portal.cz/view/1da78849 Embed
Download Paste or View Raw
  1. /*
  2. *  Copyright (C) 2012  mr.sysel
  3. *
  4. *  This file is part of TOR Shared 2.0
  5. *
  6. *  This program is free software; you can redistribute it and/or modify
  7. *  it under the terms of the GNU General Public License as published by
  8. *  the Free Software Foundation; either version 2 of the License, or
  9. *  (at your option) any later version.
  10. *
  11. *  This program is distributed in the hope that it will be useful,
  12. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. *  GNU General Public License for more details.
  15. *  
  16. */
  17.  
  18. #include "stdafx.h"
  19.  
  20.  
  21. TOR_ERROR TORUrlVarsInit(TOR_URL_VARS **lpVars)
  22. {
  23.         TOR_URL_VARS    *lpRet = NULL;
  24.         TOR_ERROR               rError;
  25.  
  26.  
  27.         __try {
  28.  
  29.                 if ((rError = TOR_NEW(lpRet)) != ERROR_SUCCESS) {
  30.                         return rError;
  31.                 }
  32.  
  33.                 lpRet->lpFirst  = NULL;
  34.                 lpRet->lpLast   = NULL;
  35.  
  36.                 TOR_RET_PTR(lpVars, lpRet);
  37.  
  38.         }
  39.  
  40.         __finally {
  41.  
  42.                 TORUrlVarsDestroy(lpRet);
  43.  
  44.         }
  45.  
  46.         return ERROR_SUCCESS;
  47. }
  48.  
  49. void TORUrlVarsDestroy(TOR_URL_VARS *lpVars)
  50. {
  51.  
  52.         if (lpVars != NULL) {
  53.  
  54.                 TORUrlVarsRemoveAll(lpVars);
  55.                 TOR_FREE(lpVars);
  56.  
  57.         }
  58.  
  59.         return;
  60. }
  61.  
  62. void TORUrlVarsRemoveAll(TOR_URL_VARS *lpVars)
  63. {
  64.         TOR_URL_VAR *lpCurr;
  65.         TOR_URL_VAR *lpNext;
  66.  
  67.  
  68.         lpCurr = lpVars->lpFirst;
  69.  
  70.         while (lpCurr) {
  71.  
  72.                 lpNext = lpCurr->lpNext;
  73.  
  74.                 TORUrlVarDestroy(lpCurr);
  75.  
  76.                 lpCurr = lpNext;
  77.  
  78.         }
  79.  
  80.         lpVars->lpFirst         = NULL;
  81.         lpVars->lpLast          = NULL;
  82.  
  83.         return;
  84. }
  85.  
  86. TOR_URL_VAR *TORUrlVarsGetFirst(TOR_URL_VARS *lpVars)
  87. {
  88.         return lpVars->lpFirst;
  89. }
  90.  
  91. TOR_URL_VAR *TORUrlVarsGetNext(TOR_URL_VAR *lpVar)
  92. {
  93.         return lpVar->lpNext;
  94. }
  95.  
  96. TOR_URL_VAR *TORUrlVarsGet(TOR_URL_VARS *lpVars, const char *lpName)
  97. {
  98.         TOR_URL_VAR *lpCurr;
  99.  
  100.  
  101.         lpCurr = lpVars->lpFirst;
  102.  
  103.         while (lpCurr) {
  104.  
  105.                 if (stricmp(lpCurr->lpName, lpName) == 0) {
  106.                         return lpCurr;
  107.                 }
  108.  
  109.                 lpCurr = lpCurr->lpNext;
  110.  
  111.         }
  112.  
  113.         return NULL;
  114. }
  115.  
  116. const char *TORUrlVarsGetValue(TOR_URL_VARS *lpVars, const char *lpName, const char *lpDefaultValue)
  117. {
  118.         TOR_URL_VAR *lpVar;
  119.  
  120.  
  121.         if ((lpVar = TORUrlVarsGet(lpVars, lpName)) != NULL) {
  122.                 return lpVar->lpValue;
  123.         }
  124.  
  125.         return lpDefaultValue;
  126. }
  127.  
  128. TOR_ERROR TORUrlVarsSetFmt(TOR_URL_VARS *lpVars, const char *lpName, const char *lpFormat, ...)
  129. {
  130.         TOR_URL_VAR             *lpVar;
  131.         va_list                 args;
  132.         TOR_ERROR               rError;
  133.  
  134.  
  135.         if ((lpVar = TORUrlVarsGet(lpVars, lpName)) != NULL) {
  136.  
  137.                 va_start(args, lpFormat);
  138.  
  139.                 rError = TORUrlVarSetValueVFmt(
  140.                         lpVar,
  141.                         lpFormat,
  142.                         args
  143.                 );
  144.  
  145.                 va_end(args);
  146.  
  147.                 if (rError != ERROR_SUCCESS) {
  148.                         return rError;
  149.                 }
  150.  
  151.  
  152.         }
  153.         else {
  154.  
  155.                 rError = TORUrlVarInit(
  156.                         &lpVar,
  157.                         lpName,
  158.                         FALSE,
  159.                         NULL,
  160.                         FALSE
  161.                 );
  162.  
  163.                 if (rError != ERROR_SUCCESS) {
  164.                         return rError;
  165.                 }
  166.  
  167.                 va_start(args, lpFormat);
  168.  
  169.                 rError = TORUrlVarSetValueVFmt(
  170.                         lpVar,
  171.                         lpFormat,
  172.                         args
  173.                 );
  174.  
  175.                 va_end(args);
  176.  
  177.                 if (rError != ERROR_SUCCESS) {
  178.  
  179.                         TORUrlVarDestroy(lpVar);
  180.  
  181.                         return rError;
  182.                 }
  183.  
  184.                 TOR_LIST_APPEND(lpVars, lpVar);
  185.  
  186.         }
  187.  
  188.         return ERROR_SUCCESS;
  189. }
  190.  
  191. TOR_ERROR TORUrlVarsSet(TOR_URL_VARS *lpVars, const char *lpName, const char *lpValue)
  192. {
  193.         return TORUrlVarsSetFmt(lpVars, lpName, "%s", lpValue);
  194. }
  195.  
  196. void TORUrlVarsRemove(TOR_URL_VARS *lpVars, const char *lpName)
  197. {
  198.         TOR_URL_VAR *lpVar;
  199.  
  200.  
  201.         if ((lpVar = TORUrlVarsGet(lpVars, lpName)) != NULL) {
  202.  
  203.                 TOR_LIST_REMOVE(lpVars, lpVar);
  204.                 TORUrlVarDestroy(lpVar);
  205.  
  206.         }
  207.  
  208.         return;
  209. }
  210.  
  211. TOR_ERROR TORUrlVarsParse(TOR_URL_VARS *lpVars, const char *lpString, const char *lpSep)
  212. {
  213.         char                    *lpTemp = NULL;
  214.         char                    *lpCurr;
  215.         char                    *lpName;
  216.         char                    *lpValue;
  217.         TOR_URL_VAR             *lpVar;
  218.         TOR_ERROR               rError;
  219.  
  220.  
  221.         __try {
  222.  
  223.                 TORUrlVarsRemoveAll(lpVars);
  224.  
  225.                 if ((rError = TORDupStr(&lpTemp, lpString)) != ERROR_SUCCESS) {
  226.                         return rError;
  227.                 }
  228.  
  229.                 while (lpCurr = TORSplit(&lpTemp, lpSep)) {
  230.  
  231.                         lpValue         = lpCurr;
  232.                         lpName          = TORTrim(TORSplit(&lpValue, "="));
  233.  
  234.                         if (*lpName != '\0') {
  235.  
  236.                                 if (TORUrlVarsGet(lpVars, lpName) == NULL) {
  237.  
  238.                                         if (lpValue != NULL) {
  239.                                                 lpValue = TORTrim(lpValue);
  240.                                         }
  241.                                         else {
  242.                                                 lpValue = "";
  243.                                         }
  244.  
  245.                                         rError = TORUrlVarInit(
  246.                                                 &lpVar,
  247.                                                 lpName,
  248.                                                 TRUE,
  249.                                                 lpValue,
  250.                                                 TRUE
  251.                                         );
  252.  
  253.                                         if (rError != ERROR_SUCCESS) {
  254.                                                 return rError;
  255.                                         }
  256.  
  257.                                         TOR_LIST_APPEND(lpVars, lpVar);
  258.  
  259.                                 }
  260.  
  261.                         }
  262.  
  263.                 }
  264.  
  265.         }
  266.  
  267.         __finally {
  268.  
  269.                 if (lpTemp != NULL) {
  270.                         TOR_FREE(lpTemp);
  271.                 }
  272.  
  273.         }
  274.  
  275.         return ERROR_SUCCESS;
  276. }
  277.  
  278. TOR_ERROR TORUrlVarsParseQuery(TOR_URL_VARS *lpVars, const char *lpQuery)
  279. {
  280.         return TORUrlVarsParse(lpVars, lpQuery, "&");
  281. }
  282.  
  283. TOR_ERROR TORUrlVarsParseCookie(TOR_URL_VARS *lpVars, const char *lpCookie)
  284. {
  285.         return TORUrlVarsParse(lpVars, lpCookie, ";");
  286. }
  287.  
  288. DWORD TORUrlVarsBuild(TOR_URL_VARS *lpVars, char *lpBuffer, DWORD dwBufferLength, const char *lpSec)
  289. {
  290.         TOR_URL_VAR             *lpCurr;
  291.         DWORD                   dwLength;
  292.  
  293.  
  294.         if (lpBuffer == NULL) {
  295.                 dwBufferLength = 0;
  296.         }
  297.  
  298.         lpCurr          = lpVars->lpFirst;
  299.         dwLength        = 0;
  300.  
  301.         while (lpCurr) {
  302.  
  303.                 dwLength += TORRawUrlEncode(
  304.                         lpBuffer != NULL ? lpBuffer + dwLength : NULL,
  305.                         dwBufferLength != 0 ? dwBufferLength - dwLength : 0,
  306.                         lpCurr->lpName
  307.                 );
  308.  
  309.                 dwLength += TORCopyStr(
  310.                         lpBuffer != NULL ? lpBuffer + dwLength : NULL,
  311.                         "=",
  312.                         dwBufferLength != 0 ? dwBufferLength - dwLength : 0
  313.                 );
  314.  
  315.                 dwLength += TORRawUrlEncode(
  316.                         lpBuffer != NULL ? lpBuffer + dwLength : NULL,
  317.                         dwBufferLength != 0 ? dwBufferLength - dwLength : 0,
  318.                         lpCurr->lpValue
  319.                 );
  320.  
  321.                 if (lpCurr != lpVars->lpLast) {
  322.  
  323.                         dwLength += TORCopyStr(
  324.                                 lpBuffer != NULL ? lpBuffer + dwLength : NULL,
  325.                                 lpSec,
  326.                                 dwBufferLength != 0 ? dwBufferLength - dwLength : 0
  327.                         );
  328.  
  329.                 }
  330.  
  331.                 lpCurr = lpCurr->lpNext;
  332.  
  333.         }
  334.  
  335.         if (dwBufferLength != 0) {
  336.  
  337.                 if (dwBufferLength == dwLength) {
  338.                         dwLength--;
  339.                 }
  340.  
  341.                 lpBuffer[dwLength] = '\0';
  342.  
  343.         }
  344.  
  345.         return dwLength;
  346. }
  347.  
  348. DWORD TORUrlVarsBuildQuery(TOR_URL_VARS *lpVars, char *lpBuffer, DWORD dwBufferLength)
  349. {
  350.         return TORUrlVarsBuild(lpVars, lpBuffer, dwBufferLength, "&");
  351. }
  352.  
  353. DWORD TORUrlVarsBuildCookie(TOR_URL_VARS *lpVars, char *lpBuffer, DWORD dwBufferLength)
  354. {
  355.         return TORUrlVarsBuild(lpVars, lpBuffer, dwBufferLength, ";");
  356. }
  357.  

Reply to "TORUrlVars.cpp"

Here you can reply to the paste above