TORIO.cpp

From mr.sysel, 4 Years ago, written in C, viewed 522 times.
URL http://paste.security-portal.cz/view/06279f20 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 TORIOInit(TOR_IO **lpIO, TOR_IO_METHOD *lpMethod, void *lpFd, DWORD dwOpts)
  22. {
  23.         TOR_IO          *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->lpMethod                 = lpMethod;
  34.                 lpRet->lpFd                             = lpFd;
  35.                 lpRet->lpCapWrite               = NULL;
  36.                 lpRet->lpCapRead                = NULL;
  37.                 lpRet->rError                   = ERROR_SUCCESS;
  38.                 lpRet->dwReferences             = 1;
  39.                 lpRet->dwOpts                   = dwOpts | TOR_IO_OPT_AUTO_FLUSH;
  40.                 lpRet->dwBytesWritten   = 0;
  41.  
  42.                 if (lpRet->lpFd == NULL) {
  43.  
  44.                         if ((rError = lpRet->lpMethod->lpInit(lpRet)) != ERROR_SUCCESS) {
  45.                                 return rError;
  46.                         }
  47.  
  48.                 }
  49.  
  50.                 TOR_RET_PTR(lpIO, lpRet);
  51.  
  52.         }
  53.  
  54.         __finally {
  55.  
  56.                 TORIODestroy(lpRet);
  57.  
  58.         }
  59.  
  60.         return ERROR_SUCCESS;
  61. }
  62.  
  63. void TORIODestroy(TOR_IO *lpIO)
  64. {
  65.  
  66.         if (lpIO != NULL) {
  67.  
  68.                 if (--lpIO->dwReferences == 0) {
  69.  
  70.                         if (lpIO->dwOpts & TOR_IO_OPT_DESTROY) {
  71.                                 lpIO->lpMethod->lpDestroy(lpIO);
  72.                         }
  73.  
  74.                         TOR_FREE(lpIO);
  75.  
  76.                 }
  77.  
  78.         }
  79.  
  80.         return;
  81. }
  82.  
  83. void TORIOClose(TOR_IO *lpIO)
  84. {
  85.  
  86.         lpIO->lpMethod->lpClose(lpIO);
  87.  
  88.         lpIO->dwBytesWritten = 0;
  89.  
  90.         return;
  91. }
  92.  
  93. TOR_IO *TORIODup(TOR_IO *lpIO)
  94. {
  95.  
  96.         lpIO->dwReferences++;
  97.  
  98.         return lpIO;
  99. }
  100.  
  101. DWORD TORIOGetType(TOR_IO *lpIO)
  102. {
  103.         return lpIO->lpMethod->dwType;
  104. }
  105.  
  106. DWORD TORIOGetMode(TOR_IO *lpIO)
  107. {
  108.         return lpIO->lpMethod->dwMode;
  109. }
  110.  
  111. const char *TORIOGetName(TOR_IO *lpIO)
  112. {
  113.         return lpIO->lpMethod->lpName;
  114. }
  115.  
  116. void *TORIOGetFd(TOR_IO *lpIO)
  117. {
  118.         return lpIO->lpFd;
  119. }
  120.  
  121. TOR_EVENT *TORIOGetEvent(TOR_IO *lpIO)
  122. {
  123.         return lpIO->lpMethod->lpGetEvent(lpIO);
  124. }
  125.  
  126. TOR_EVENT *TORIOGetAbortEvent(TOR_IO *lpIO)
  127. {
  128.         return lpIO->lpMethod->lpGetAbortEvent(lpIO);
  129. }
  130.  
  131. void TORIOSetOpts(TOR_IO *lpIO, DWORD dwOpts)
  132. {
  133.  
  134.         lpIO->dwOpts |= dwOpts;
  135.  
  136.         return;
  137. }
  138.  
  139. void TORIOClearOpts(TOR_IO *lpIO, DWORD dwOpts)
  140. {
  141.  
  142.         lpIO->dwOpts &= ~dwOpts;
  143.  
  144.         return;
  145. }
  146.  
  147. DWORD TORIOGetOpts(TOR_IO *lpIO)
  148. {
  149.         return lpIO->dwOpts;
  150. }
  151.  
  152. void TORIOSetCapWrite(TOR_IO *lpIO, TOR_IO_CATPURE_WRITE_PROC *lpWrite, void *lpParam)
  153. {
  154.  
  155.         lpIO->lpCapWrite                = lpWrite;
  156.         lpIO->lpCapWriteParam   = lpParam;
  157.  
  158.         return;
  159. }
  160.  
  161. void TORIOSetCapRead(TOR_IO *lpIO, TOR_IO_CAPTURE_READ_PROC *lpRead, void *lpParam)
  162. {
  163.  
  164.         lpIO->lpCapRead                 = lpRead;
  165.         lpIO->lpCapReadParam    = lpParam;
  166.  
  167.         return;
  168. }
  169.  
  170. void TORIOSetLastError(TOR_IO *lpIO, TOR_ERROR rError)
  171. {
  172.  
  173.         lpIO->rError = rError;
  174.  
  175.         return;
  176. }
  177.  
  178. TOR_ERROR TORIOGetLastError(TOR_IO *lpIO)
  179. {
  180.         return lpIO->rError;
  181. }
  182.  
  183. void TORIOReplace(TOR_IO *lpSrcIO, TOR_IO **lpDestIO)
  184. {
  185.  
  186.         if (*lpDestIO != NULL) {
  187.                 TORIODestroy(*lpDestIO);
  188.         }
  189.  
  190.         *lpDestIO = lpSrcIO;
  191.  
  192.         return;
  193. }
  194.  
  195. char *TORIOGetWriteBuffer(TOR_IO *lpIO)
  196. {
  197.         return lpIO->szWriteBuffer;
  198. }
  199.  
  200. DWORD TORIOGetBytesWritten(TOR_IO *lpIO)
  201. {
  202.         return lpIO->dwBytesWritten;
  203. }
  204.  
  205. void TORIOCleanWriteBuffer(TOR_IO *lpIO)
  206. {
  207.  
  208.         lpIO->dwBytesWritten = 0;
  209.  
  210.         return;
  211. }
  212.  
  213. TOR_ERROR TORIOFlush(TOR_IO *lpIO)
  214. {
  215.         TOR_ERROR rError;
  216.  
  217.  
  218.         if (lpIO->dwBytesWritten != 0) {
  219.  
  220.                 if (lpIO->lpCapWrite != NULL) {
  221.  
  222.                         rError = lpIO->lpCapWrite(
  223.                                 lpIO->lpCapWriteParam,
  224.                                 lpIO,
  225.                                 lpIO->szWriteBuffer,
  226.                                 lpIO->dwBytesWritten
  227.                         );
  228.  
  229.                         if (rError != ERROR_SUCCESS) {
  230.  
  231.                                 lpIO->dwBytesWritten = 0;
  232.  
  233.                                 return rError;
  234.                         }
  235.  
  236.                 }
  237.  
  238.                 rError = lpIO->lpMethod->lpWrite(
  239.                         lpIO,
  240.                         lpIO->szWriteBuffer,
  241.                         lpIO->dwBytesWritten
  242.                 );
  243.  
  244.                 lpIO->dwBytesWritten = 0;
  245.  
  246.                 if (rError != ERROR_SUCCESS) {
  247.                         return rError;
  248.                 }
  249.  
  250.         }
  251.  
  252.         return ERROR_SUCCESS;
  253. }
  254.  
  255. TOR_ERROR TORIOWrite(TOR_IO *lpIO, const char *lpData, DWORD dwDataLength)
  256. {
  257.         DWORD           dwBytesToWrite;
  258.         TOR_ERROR       rError;
  259.  
  260.  
  261.         if (dwDataLength == 0xFFFFFFFF) {
  262.                 dwDataLength = strlen(lpData);
  263.         }
  264.  
  265.         while (dwDataLength != 0) {
  266.  
  267.                 dwBytesToWrite = dwDataLength;
  268.  
  269.                 if (dwBytesToWrite > sizeof(lpIO->szWriteBuffer) - lpIO->dwBytesWritten) {
  270.                         dwBytesToWrite = sizeof(lpIO->szWriteBuffer) - lpIO->dwBytesWritten;
  271.                 }
  272.  
  273.                 memcpy(
  274.                         lpIO->szWriteBuffer + lpIO->dwBytesWritten,
  275.                         lpData,
  276.                         dwBytesToWrite
  277.                 );
  278.  
  279.                 lpIO->dwBytesWritten    += dwBytesToWrite;
  280.  
  281.                 lpData                                  += dwBytesToWrite;
  282.                 dwDataLength                    -= dwBytesToWrite;
  283.  
  284.                 if (lpIO->dwOpts & TOR_IO_OPT_WRITE_BUFFER) {
  285.  
  286.                         if (lpIO->dwBytesWritten == sizeof(lpIO->szWriteBuffer)) {
  287.  
  288.                                 if (lpIO->dwOpts & TOR_IO_OPT_AUTO_FLUSH) {
  289.  
  290.                                         if ((rError = TORIOFlush(lpIO)) != ERROR_SUCCESS) {
  291.                                                 return rError;
  292.                                         }
  293.  
  294.                                 }
  295.                                 else {
  296.  
  297.                                         if (dwDataLength != 0) {
  298.                                                 return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, ERROR_NOT_ENOUGH_MEMORY);
  299.                                         }
  300.  
  301.                                 }
  302.  
  303.                         }
  304.  
  305.                 }
  306.                 else {
  307.  
  308.                         if ((rError = TORIOFlush(lpIO)) != ERROR_SUCCESS) {
  309.                                 return rError;
  310.                         }
  311.  
  312.                 }
  313.  
  314.  
  315.         }
  316.  
  317.         return ERROR_SUCCESS;
  318. }
  319.  
  320. TOR_ERROR TORIOPutChar(TOR_IO *lpIO, char c)
  321. {
  322.         char *lpData = &c;
  323.  
  324.         return TORIOWrite(lpIO, lpData, sizeof(char));
  325. }
  326.  
  327. TOR_ERROR TORIOGetChar(TOR_IO *lpIO, char *c)
  328. {
  329.         TOR_ERROR       rError;
  330.         DWORD           dwBytesReaded;
  331.  
  332.  
  333.         if ((rError = TORIORead(lpIO, c, sizeof(char), &dwBytesReaded)) != ERROR_SUCCESS) {
  334.                 return rError;
  335.         }
  336.  
  337.         if (dwBytesReaded == 0) {
  338.                 return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_END_OF_STREAM);
  339.         }
  340.  
  341.         return ERROR_SUCCESS;
  342. }
  343.  
  344. TOR_ERROR TORIOPuts(TOR_IO *lpIO, const char *lpData)
  345. {
  346.         return TORIOWrite(lpIO, lpData, strlen(lpData));
  347. }
  348.  
  349. TOR_ERROR TORIOPeek(TOR_IO *lpIO, char *lpBuffer, DWORD dwBufferLength, DWORD *lpBytesReaded)
  350. {
  351.         return lpIO->lpMethod->lpPeek(lpIO, lpBuffer, dwBufferLength, lpBytesReaded);
  352. }
  353.  
  354. TOR_ERROR TORIOSeek(TOR_IO *lpIO, DWORD dwOffset)
  355. {
  356.         return lpIO->lpMethod->lpSeek(lpIO, dwOffset);
  357. }
  358.  
  359. TOR_ERROR TORIORead(TOR_IO *lpIO, char *lpBuffer, DWORD dwBufferLength, DWORD *lpBytesReaded)
  360. {
  361.         TOR_ERROR rError;
  362.  
  363.  
  364.         rError = lpIO->lpMethod->lpRead(
  365.                 lpIO,
  366.                 lpBuffer,
  367.                 dwBufferLength,
  368.                 lpBytesReaded
  369.         );
  370.  
  371.         if (rError != ERROR_SUCCESS) {
  372.                 return rError;
  373.         }
  374.  
  375.         if (lpIO->lpCapRead != NULL && *lpBytesReaded != 0) {
  376.  
  377.                 rError = lpIO->lpCapRead(
  378.                         lpIO->lpCapReadParam,
  379.                         lpIO,
  380.                         lpBuffer,
  381.                         *lpBytesReaded
  382.                 );
  383.  
  384.                 if (rError != ERROR_SUCCESS) {
  385.                         return rError;
  386.                 }
  387.  
  388.         }
  389.  
  390.         return rError;
  391. }
  392.  
  393. TOR_ERROR TORIOReadLine(TOR_IO *lpIO, char *lpBuffer, DWORD dwBufferLength, DWORD *lpLineLength, DWORD *lpFactualLength)
  394. {
  395.         char            szRecvBuffer[1024];
  396.         char            szCRLF[2];
  397.         char            c;
  398.         DWORD           dwBytesReaded;
  399.         DWORD           dwLineLength;
  400.         DWORD           dwFactualLength;
  401.         DWORD           i;
  402.         TOR_ERROR       rError;
  403.  
  404.  
  405.         if (lpBuffer == NULL) {
  406.                 dwBufferLength = 0;
  407.         }
  408.  
  409.         if (dwBufferLength > 0) {
  410.  
  411.                 *lpBuffer = '\0';
  412.  
  413.                 dwBufferLength--;
  414.  
  415.         }
  416.  
  417.         if (lpLineLength != NULL) {
  418.                 *lpLineLength = 0;
  419.         }
  420.  
  421.         if (lpFactualLength != NULL) {
  422.                 *lpFactualLength = 0;
  423.         }
  424.  
  425.         ZeroMemory(szCRLF, sizeof(szCRLF));
  426.  
  427.         dwFactualLength         = 0;
  428.         dwLineLength            = 0;
  429.  
  430.         do {
  431.  
  432.                 rError = TORIOPeek(
  433.                         lpIO,
  434.                         szRecvBuffer,
  435.                         sizeof(szRecvBuffer),
  436.                         &dwBytesReaded
  437.                 );
  438.  
  439.                 if (rError != ERROR_SUCCESS) {
  440.                         break;
  441.                 }
  442.  
  443.                 if (dwBytesReaded == 0) {
  444.                         return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_END_OF_STREAM);
  445.                 }
  446.  
  447.                 for (i = 0; i < dwBytesReaded; i++) {
  448.  
  449.                         c = szRecvBuffer[i];
  450.  
  451.                         szCRLF[0] = szCRLF[1];
  452.                         szCRLF[1] = c;
  453.  
  454.                         if (szCRLF[0] == '\r' && szCRLF[1] == '\n') {
  455.  
  456.                                 dwFactualLength--;
  457.  
  458.                                 if (dwLineLength > 0) {
  459.  
  460.                                         if (lpBuffer[dwLineLength - 1] == '\r') {
  461.                                                 dwLineLength--;
  462.                                         }
  463.  
  464.                                         lpBuffer[dwLineLength] = '\0';
  465.  
  466.                                 }
  467.  
  468.                                 if ((rError = TORIOSeek(lpIO, i + 1)) != ERROR_SUCCESS) {
  469.                                         return rError;
  470.                                 }
  471.  
  472.                                 if (lpLineLength != NULL) {
  473.                                         *lpLineLength = dwLineLength;
  474.                                 }
  475.  
  476.                                 if (lpFactualLength != NULL) {
  477.                                         *lpFactualLength = dwFactualLength;
  478.                                 }
  479.  
  480.                                 return ERROR_SUCCESS;
  481.                         }
  482.  
  483.                         dwFactualLength++;
  484.  
  485.                         if (dwLineLength < dwBufferLength) {
  486.                                 lpBuffer[dwLineLength++] = c;
  487.                         }
  488.  
  489.                 }
  490.  
  491.                 if ((rError = TORIOSeek(lpIO, dwBytesReaded)) != ERROR_SUCCESS) {
  492.                         return rError;
  493.                 }
  494.  
  495.         } while (1);
  496.  
  497.         return rError;
  498. }
  499.  
  500. TOR_ERROR TORIOReadChunk(TOR_IO *lpIO, char *lpBuffer, DWORD dwBufferLength)
  501. {
  502.         DWORD           dwTotalReaded = 0;
  503.         DWORD           dwBytesReaded;
  504.         TOR_ERROR       rError;
  505.  
  506.  
  507.         do {
  508.  
  509.                 rError = TORIORead(
  510.                         lpIO,
  511.                         lpBuffer + dwTotalReaded,
  512.                         dwBufferLength - dwTotalReaded,
  513.                         &dwBytesReaded
  514.                 );
  515.  
  516.                 if (rError != ERROR_SUCCESS) {
  517.                         return rError;
  518.                 }
  519.  
  520.                 if (dwBytesReaded == 0) {
  521.                         return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_END_OF_STREAM);
  522.                 }
  523.  
  524.                 dwTotalReaded += dwBytesReaded;
  525.  
  526.         } while (dwTotalReaded < dwBufferLength);
  527.  
  528.         return ERROR_SUCCESS;
  529. }
  530.  
  531. TOR_ERROR TORIOCopyTo(TOR_IO *lpFromIO, TOR_IO *lpToIO)
  532. {
  533.         char            szBuffer[TOR_IO_BUFFER_SIZE];
  534.         DWORD           dwBytesReaded;
  535.         TOR_ERROR       rError;
  536.  
  537.         do {
  538.  
  539.                 rError = TORIORead(
  540.                         lpFromIO,
  541.                         szBuffer,
  542.                         sizeof(szBuffer),
  543.                         &dwBytesReaded
  544.                 );
  545.  
  546.                 if (rError != ERROR_SUCCESS) {
  547.                         return rError;
  548.                 }
  549.  
  550.                 if (dwBytesReaded == 0) {
  551.                         break;
  552.                 }
  553.  
  554.                 rError = TORIOWrite(
  555.                         lpToIO,
  556.                         szBuffer,
  557.                         dwBytesReaded
  558.                 );
  559.  
  560.                 if (rError != ERROR_SUCCESS) {
  561.                         return rError;
  562.                 }
  563.  
  564.         } while (1);
  565.  
  566.         return ERROR_SUCCESS;
  567. }
  568.  
  569. TOR_ERROR TORIOCopyToEx(TOR_IO *lpFromIO, TOR_IO *lpToIO, DWORD dwLength)
  570. {
  571.         char            szBuffer[TOR_IO_BUFFER_SIZE];
  572.         DWORD           dwBytesToRead;
  573.         DWORD           dwBytesReaded;
  574.         TOR_ERROR       rError;
  575.  
  576.  
  577.         do {
  578.  
  579.                 dwBytesToRead = dwLength;
  580.  
  581.                 if (dwBytesToRead > sizeof(szBuffer)) {
  582.                         dwBytesToRead = sizeof(szBuffer);
  583.                 }
  584.  
  585.                 if (dwBytesToRead != 0) {
  586.  
  587.                         rError = TORIORead(
  588.                                 lpFromIO,
  589.                                 szBuffer,
  590.                                 dwBytesToRead,
  591.                                 &dwBytesReaded
  592.                         );
  593.  
  594.                         if (rError != ERROR_SUCCESS) {
  595.                                 return rError;
  596.                         }
  597.  
  598.                         if (dwBytesReaded == 0) {
  599.                                 return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_END_OF_STREAM);
  600.                         }
  601.  
  602.                         rError = TORIOWrite(
  603.                                 lpToIO,
  604.                                 szBuffer,
  605.                                 dwBytesReaded
  606.                         );
  607.  
  608.                         if (rError != ERROR_SUCCESS) {
  609.                                 return rError;
  610.                         }
  611.  
  612.                         dwLength -= dwBytesReaded;
  613.  
  614.                 }
  615.  
  616.         } while (dwLength != 0);
  617.  
  618.         return ERROR_SUCCESS;
  619. }
  620.  
  621. TOR_ERROR TORIOForward(TOR_IO *lpFromIO, TOR_IO *lpToIO, DWORD dwTimeout)
  622. {
  623.         TOR_EVENTS      *lpEvents = NULL;
  624.         char            szBuffer[TOR_IO_BUFFER_SIZE];
  625.         DWORD           dwBytesReaded;
  626.         TOR_ERROR       rError;
  627.  
  628.  
  629.         __try {
  630.  
  631.                 if ((rError = TOREventsInit(&lpEvents, INFINITE)) != ERROR_SUCCESS) {
  632.                         return rError;
  633.                 }
  634.  
  635.                 if (TORIOGetAbortEvent(lpFromIO) != NULL) {
  636.  
  637.                         rError = TOREventsAdd(
  638.                                 lpEvents,
  639.                                 TOR_IO_EVENT_ABORT_FROM,
  640.                                 TORIOGetAbortEvent(lpFromIO)
  641.                         );
  642.  
  643.                         if (rError != ERROR_SUCCESS) {
  644.                                 return rError;
  645.                         }
  646.  
  647.                 }
  648.  
  649.                 if (TORIOGetAbortEvent(lpToIO) != NULL) {
  650.  
  651.                         rError = TOREventsAdd(
  652.                                 lpEvents,
  653.                                 TOR_IO_EVENT_ABORT_TO,
  654.                                 TORIOGetAbortEvent(lpToIO)
  655.                         );
  656.  
  657.                         if (rError != ERROR_SUCCESS) {
  658.                                 return rError;
  659.                         }
  660.  
  661.                 }
  662.  
  663.                 if (TORIOGetEvent(lpFromIO) == NULL) {
  664.                         return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_NOT_SUPPORTED);
  665.                 }
  666.  
  667.                 rError = TOREventsAdd(
  668.                         lpEvents,
  669.                         TOR_IO_EVENT_FROM,
  670.                         TORIOGetEvent(lpFromIO)
  671.                 );
  672.  
  673.                 if (rError != ERROR_SUCCESS) {
  674.                         return rError;
  675.                 }
  676.  
  677.                 if (TORIOGetEvent(lpToIO) == NULL) {
  678.                         return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_NOT_SUPPORTED);
  679.                 }
  680.  
  681.                 rError = TOREventsAdd(
  682.                         lpEvents,
  683.                         TOR_IO_EVENT_TO,
  684.                         TORIOGetEvent(lpToIO)
  685.                 );
  686.  
  687.                 if (rError != ERROR_SUCCESS) {
  688.                         return rError;
  689.                 }
  690.  
  691.                 do {
  692.  
  693.                         if ((rError = TOREventsWait(lpEvents, dwTimeout)) != ERROR_SUCCESS) {
  694.                                 return rError;
  695.                         }
  696.  
  697.                         switch (TOREventsGetLastID(lpEvents)) {
  698.  
  699.                                 case TOR_IO_EVENT_ABORT_FROM:
  700.                                 case TOR_IO_EVENT_ABORT_TO:
  701.                                         return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_OPERATION_ABORTED);
  702.                                 break;
  703.  
  704.                                 case TOR_IO_EVENT_FROM:
  705.  
  706.                                         rError = TORIORead(
  707.                                                 lpFromIO,
  708.                                                 szBuffer,
  709.                                                 sizeof(szBuffer),
  710.                                                 &dwBytesReaded
  711.                                         );
  712.  
  713.                                         if (rError != ERROR_SUCCESS) {
  714.                                                 return rError;
  715.                                         }
  716.  
  717.                                         if (dwBytesReaded == 0) {
  718.                                                 return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_END_OF_STREAM);
  719.                                         }
  720.  
  721.                                         rError = TORIOWrite(
  722.                                                 lpToIO,
  723.                                                 szBuffer,
  724.                                                 dwBytesReaded
  725.                                         );
  726.  
  727.                                         if (rError != ERROR_SUCCESS) {
  728.                                                 return rError;
  729.                                         }
  730.  
  731.                                 break;
  732.  
  733.                                 case TOR_IO_EVENT_TO:
  734.  
  735.                                         rError = TORIORead(
  736.                                                 lpToIO,
  737.                                                 szBuffer,
  738.                                                 sizeof(szBuffer),
  739.                                                 &dwBytesReaded
  740.                                         );
  741.  
  742.                                         if (rError != ERROR_SUCCESS) {
  743.                                                 return rError;
  744.                                         }
  745.  
  746.                                         if (dwBytesReaded == 0) {
  747.                                                 return TOR_ERROR_CREATE(TOR_ERROR_CLASS_WINAPI, TOR_ERROR_IO_END_OF_STREAM);
  748.                                         }
  749.  
  750.                                         rError = TORIOWrite(
  751.                                                 lpFromIO,
  752.                                                 szBuffer,
  753.                                                 dwBytesReaded
  754.                                         );
  755.  
  756.                                         if (rError != ERROR_SUCCESS) {
  757.                                                 return rError;
  758.                                         }
  759.  
  760.                                 break;
  761.  
  762.                         }
  763.  
  764.                 } while (1);
  765.  
  766.         }
  767.  
  768.         __finally {
  769.  
  770.                 TOREventsDestroy(lpEvents);
  771.  
  772.         }
  773.  
  774.         return ERROR_SUCCESS;
  775. }
  776.  

Reply to "TORIO.cpp"

Here you can reply to the paste above