home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 35 Internet / 35-Internet.zip / lpopper.zip / mbox.c- < prev    next >
Text File  |  1997-12-06  |  44KB  |  1,255 lines
  1. #include "popper.h"
  2.  
  3. int Debug=0;
  4.  
  5. struct Letter  *mBox=NULL;
  6. long msgCount=0;
  7. long TotalLen=0;
  8. long uMsgCount=0;
  9. long uTotalLen=0;
  10. char PwdPath[512]="passwd";
  11. char BoxPath[512]=".\\";
  12.  
  13. #pragma argsused
  14. int PackBox(char * User, int DoDelete)
  15. { FILE *Tmp;
  16.   FILE *fBox;
  17.   FILE *rBox;
  18.   char TmpPath[512];
  19.   char mBoxPath[512];
  20.   char rBoxPath[512];
  21.   long i, Len;
  22.   int Res;
  23.  
  24.  
  25.   if(DoDelete==0)
  26.     { for(i=0;i<msgCount;i++)
  27.         mBox[i].Deleted=0;
  28.       uMsgCount=msgCount;
  29.       uTotalLen=TotalLen;
  30.     }
  31.   sprintf(TmpPath, "%s%s.tmp", BoxPath, User);
  32.   sprintf(mBoxPath, "%s%s.mb", BoxPath, User);
  33.   sprintf(rBoxPath, "%s%s", BoxPath, User);
  34.  
  35.   if(msgCount==0)
  36.     { unlink(mBoxPath);
  37.       return(0);
  38.     }
  39.   Tmp =_fsopen(TmpPath, "wb", SH_DENYRW);
  40.   if(Tmp==NULL)
  41.     { perror("Can't create temporary mailbox");
  42.       return(-1);
  43.     }
  44.   fBox=_fsopen(mBoxPath, "rb", SH_DENYRW);
  45.   if(fBox==NULL)
  46.     { perror("Can't open mailbox");
  47.       fclose(Tmp);
  48.       return(-1);
  49.     }
  50.  
  51.   for(i=0;i<msgCount;i++)
  52.    { 
  53. /*     fprintf(stderr,
  54.              "Message %lu\n"
  55.              "From %lX to %lX\n"
  56.              "Header to %lX\n"
  57.              "Status from %lX to %lX\n"
  58.              "Status=%u, Old Status=%u\n",
  59.              i,
  60.              mBox[i].Begin, mBox[i].End,
  61.              mBox[i].hEnd,
  62.              mBox[i].sBeg, mBox[i].sEnd, mBox[i].Status, mBox[i].oStatus);*/
  63.  
  64.      if(mBox[i].Deleted) continue;
  65.  
  66. /*************************************************************/
  67.      if(mBox[i].oStatus==None)
  68.        { if(CopyBlock(fBox, Tmp, mBox[i].Begin, mBox[i].hEnd)!=0)
  69.            { perror("Mailbox -> TempBox copy failed");
  70.              fclose(Tmp);
  71.              unlink(TmpPath);
  72.              fclose(fBox);
  73.              return(-1);
  74.            }
  75.          switch(mBox[i].Status)
  76.           { case Unreaded : Res=AddBlock(Tmp, "Status: U\x0D\x0A");
  77.                             break;
  78.             case Readed   : Res=AddBlock(Tmp, "Status: R\x0D\x0A");
  79.                             break;
  80.             case Old      : Res=AddBlock(Tmp, "Status: O\x0D\x0A");
  81.                             break;
  82.             case ROld     : Res=AddBlock(Tmp, "Status: RO\x0D\x0A");
  83.                             break;
  84.             default       : Res=AddBlock(Tmp, "Status: U\x0D\x0A");
  85.                             break;
  86.           }
  87.          if(Res!=0)
  88.            { perror("Can't add \"Status:\"");
  89.              fclose(Tmp);
  90.              unlink(TmpPath);
  91.              fclose(fBox);
  92.              return(-1);
  93.            }
  94.          if(CopyBlock(fBox, Tmp, mBox[i].hEnd, mBox[i].End+1)!=0)
  95.            { perror("Mailbox -> TempBox copy failed");
  96.              fclose(Tmp);
  97.              unlink(TmpPath);
  98.              fclose(fBox);
  99.              return(-1);
  100.            }
  101.        }
  102.       else
  103.        { if(CopyBlock(fBox, Tmp, mBox[i].Begin, mBox[i].sBeg)!=0)
  104.            { perror("Mailbox -> TempBox copy failed");
  105.              fclose(Tmp);
  106.              unlink(TmpPath);
  107.              fclose(fBox);
  108.              return(-1);
  109.            }
  110.          switch(mBox[i].Status)
  111.           { case Unreaded : Res=AddBlock(Tmp, "Status: U\x0D\x0A");
  112.                             break;
  113.             case Readed   : Res=AddBlock(Tmp, "Status: R\x0D\x0A");
  114.                             break;
  115.             case Old      : Res=AddBlock(Tmp, "Status: O\x0D\x0A");
  116.                             break;
  117.             case ROld     : Res=AddBlock(Tmp, "Status: RO\x0D\x0A");
  118.                             break;
  119.             default       : Res=AddBlock(Tmp, "Status: U\x0D\x0A");
  120.                             break;
  121.           }
  122.          if(Res!=0)
  123.            { perror("Can't add \"Status:\"");
  124.              fclose(Tmp);
  125.              unlink(TmpPath);
  126.              fclose(fBox);
  127.              return(-1);
  128.            }
  129.          if(CopyBlock(fBox, Tmp, mBox[i].sEnd, mBox[i].End+1)!=0)
  130.            { perror("Mailbox -> TempBox copy failed");
  131.              fclose(Tmp);
  132.              unlink(TmpPath);
  133.              fclose(fBox);
  134.              return(-1);
  135.            }
  136.        }
  137. /************************************************/
  138.    }
  139.   fseek(Tmp, 0, SEEK_END);
  140.   Len=ftell(Tmp);
  141.   fclose(fBox);
  142.   fBox=_fsopen(mBoxPath, "wb", SH_DENYRW);
  143.   if(fBox==NULL)
  144.     { perror("Can't reopen mailbox");
  145.       fclose(Tmp);
  146.       unlink(TmpPath);
  147.       return(-1);
  148.     }
  149.   if(CopyBlock(Tmp, fBox, 0, Len)!=0)
  150.     { perror("Can't copy TmpBox to mailbox");
  151.       fclose(Tmp);
  152.       unlink(TmpPath);
  153.       fclose(fBox);
  154.       return(-1);
  155.     }
  156.    else
  157.     { 
  158.       fclose(fBox);
  159.       fclose(Tmp);
  160.       Tmp =_fsopen(TmpPath, "rb", SH_DENYRW);
  161.       if(Tmp==NULL)
  162.         { perror("Can't reopen temporary mailbox");
  163.           return(-1);
  164.         }
  165.       unlink(mBoxPath);
  166.       if(access(rBoxPath, 0)==0)
  167.         { errno=0;
  168.           rBox=_fsopen(rBoxPath, "r+b", SH_DENYRW);
  169.         }
  170.        else
  171.         { errno=0;
  172.           rBox=_fsopen(rBoxPath, "w+b", SH_DENYRW);
  173.         }
  174.       if(rBox==NULL)
  175.         { perror("Can't open maildrop");
  176.         }
  177.        else
  178.         { fseek(Tmp, 0, SEEK_END);
  179.           Len=ftell(Tmp);
  180.           if(CopyBlock(Tmp, rBox, 0l, Len)!=0)
  181.             { perror("Can't append mailbox to main maildrop : some mails wasted");
  182.             }
  183.           fclose(rBox);
  184.         }
  185.       fclose(Tmp);
  186.       unlink(TmpPath);
  187.     }
  188.  
  189.   return(0);
  190. }
  191.  
  192. static char UserName[9]={0};
  193. void CrashPack (void)
  194. { fprintf(stderr, "Session crashed for user %s, emergency packing mailbox\n");
  195.   PackBox(UserName, 0);
  196. }
  197.  
  198. #define NEWLETTER  "From "
  199. #define MSGID      "Message-Id:"
  200. #define CHARSET    "Content-Type:"
  201. #define STATUS     "Status:"
  202. #define C866       "x-cp866"
  203. /*Content-Type: text/plain; charset=x-cp866*/
  204.  
  205. int RescanBox(FILE * fBox)
  206. { long i, Begin, cBegin;
  207.   char *Buffer;
  208.  
  209. /*Allocate temporary buffer and check it*/
  210.   Buffer=(char*)malloc(10240);
  211.   if(Buffer==NULL)
  212.     { return(-1);
  213.     }
  214.  
  215. /*Clear old index if any*/
  216.   for(i=0;i<msgCount;i++)
  217.    { free(mBox[i].msgID);
  218.    }
  219.   if(mBox!=NULL) free(mBox);
  220.   msgCount=0;
  221.   TotalLen=0l;
  222.   mBox=NULL;
  223.   fseek(fBox, 0, SEEK_SET);
  224. /*Build new index*/
  225.   do { /*Skip to next From*/
  226.        do { Begin=ftell(fBox);
  227.             if(fgets(Buffer, 10230, fBox)==NULL)
  228.               { if(feof(fBox)) break;
  229.                 free(Buffer);
  230.                 for(i=0;i<msgCount;i++)
  231.                  { free(mBox[i].msgID);
  232.                  }
  233.                 if(mBox!=NULL) free(mBox);
  234.                 return(-1);
  235.               }
  236.             DelEndCRLF(Buffer);
  237.           } while(memcmp(Buffer, NEWLETTER, strlen(NEWLETTER))!=0);
  238.        if(feof(fBox)) 
  239.          { break;
  240.          }
  241.  
  242. /*New message found, allocating memory for it*/
  243.  
  244.        if(msgCount==0) mBox=(struct Letter*)malloc(sizeof(struct Letter));
  245.         else mBox=(struct Letter*)realloc(mBox, sizeof(struct Letter)*(msgCount+1));
  246.        if(mBox==NULL)
  247.          { return(-1);
  248.          }
  249.  
  250. /*Let's set values*/
  251.        mBox[msgCount].Begin=Begin;
  252.        if(msgCount!=0)
  253.          { mBox[msgCount-1].End=mBox[msgCount].Begin-1;
  254.            mBox[msgCount-1].Size=mBox[msgCount-1].End-mBox[msgCount-1].Begin+1;
  255.            TotalLen+=mBox[msgCount-1].Size;
  256.          }
  257.        mBox[msgCount].Deleted=0;
  258.        mBox[msgCount].Is866=0;
  259.        mBox[msgCount].msgID=(char*)malloc(1);
  260.        if(mBox[msgCount].msgID==NULL)
  261.          { for(i=0;i<msgCount;i++)
  262.             { free(mBox[i].msgID);
  263.             }
  264.            if(mBox!=NULL) free(mBox);
  265.            return(-1);
  266.          }
  267.        mBox[msgCount].msgID[0]=0;
  268.        mBox[msgCount].Status=None;
  269.        mBox[msgCount].sBeg=0;
  270.        mBox[msgCount].sEnd=0;
  271.  
  272. /*Scanning header for the CHARSET and MSGID*/
  273.        do { cBegin=ftell(fBox);
  274.             if(fgets(Buffer, 10230, fBox)==NULL)
  275.               { if(feof(fBox)) break;
  276.                 free(Buffer);
  277.                 for(i=0;i<msgCount;i++)
  278.                  { free(mBox[i].msgID);
  279.                  }
  280.                 if(mBox!=NULL) free(mBox);
  281.                 return(-1);
  282.               }
  283.             DelSpaces(Buffer);
  284.             /*Content-Type: text/plain; charset=x-cp866*/
  285.             /*C866*/
  286.             if(memicmp(Buffer, CHARSET, strlen(CHARSET))==0)
  287.               { if(strstr(Buffer, C866)!=NULL)
  288.                   { mBox[msgCount].Is866=1;
  289.                     mBox[msgCount].cBeg=cBegin;
  290.                     mBox[msgCount].cEnd=ftell(fBox);
  291.                   }
  292.                 continue;
  293.               }
  294.             if(memicmp(Buffer, MSGID, strlen(MSGID))==0)
  295.               { 
  296.                 DelSpaces(&Buffer[strlen(MSGID)]);
  297.                 mBox[msgCount].msgID=(char*)realloc(mBox[msgCount].msgID, strlen(&Buffer[strlen(MSGID)])+1);
  298.                 strcpy(mBox[msgCount].msgID, &Buffer[strlen(MSGID)+1]);
  299.                 mBox[msgCount].msgID[strlen(mBox[msgCount].msgID)-1]=0;
  300.                 continue;
  301.               }
  302.             if(memicmp(Buffer, STATUS, strlen(STATUS))==0)
  303.               { DelSpaces(&Buffer[strlen(STATUS)]);
  304.                 mBox[msgCount].sBeg=cBegin;
  305.                 mBox[msgCount].sEnd=ftell(fBox);
  306.                 if(stricmp(&Buffer[strlen(STATUS)], "U")==0)
  307.                   { mBox[msgCount].Status=Unreaded;
  308.                     continue;
  309.                   }
  310.                 if(stricmp(&Buffer[strlen(STATUS)], "R")==0)
  311.                   { mBox[msgCount].Status=Readed;
  312.                     continue;
  313.                   }
  314.                 if(stricmp(&Buffer[strlen(STATUS)], "O")==0)
  315.                   { mBox[msgCount].Status=Old;
  316.                     continue;
  317.                   }
  318.                 if(stricmp(&Buffer[strlen(STATUS)], "RO")==0)
  319.                   { mBox[msgCount].Status=ROld;
  320.                     continue;
  321.                   }
  322.                 mBox[msgCount].Status=Unreaded;
  323.               }
  324.           } while(!IsEmpty(Buffer));
  325.        mBox[msgCount].hEnd=cBegin;
  326.        mBox[msgCount].oStatus=mBox[msgCount].Status;
  327.        msgCount++;
  328.      }while(!feof(fBox));
  329.  
  330.   fseek(fBox, 0, SEEK_END);
  331.   if(msgCount>0)
  332.     {
  333.       mBox[msgCount-1].End=ftell(fBox)-1;
  334.       mBox[msgCount-1].Size=mBox[msgCount-1].End-mBox[msgCount-1].Begin+1;
  335.       TotalLen+=mBox[msgCount-1].Size;
  336.     }
  337.  
  338.   uTotalLen=TotalLen;
  339.   uMsgCount=msgCount;
  340.  
  341.   free(Buffer);
  342.  
  343.   if(msgCount==0) 
  344.     { mBox=(struct Letter*)malloc(sizeof(struct Letter));
  345.       if(mBox==NULL) return(-1);
  346.     }
  347.   return(0);
  348. }
  349.  
  350. int CheckUser(char * UserName)
  351. { struct Pwd Pw;
  352.  
  353.   strncpy(Pw.User, UserName, 8);
  354.  
  355.   if(ReadUser(&Pw, PwdPath)!=0) return(0);
  356.   if(Pw.Pass[0]=='*') return(0);
  357.  
  358.   return(1);
  359. }
  360. int CheckPass(char * User, char * Pass)
  361. { struct Pwd Pw;
  362.  
  363.   strncpy(Pw.User, User, 8);
  364.  
  365.   if(ReadUser(&Pw, PwdPath)!=0) return(0);
  366.   if(Pw.Pass[0]=='*') return(0);
  367.   if(strcmp(Pw.Pass, Pass)==0) return(1);
  368.  
  369.   return(0);
  370. }
  371.  
  372. #define USERCMD "USER"
  373. #define PASSCMD "PASS"
  374. #define QUITCMD "QUIT"
  375. #define NOCMD   "NOOP"
  376. #define STATCMD "STAT"
  377. #define LISTCMD "LIST"
  378. #define RETRCMD "RETR"
  379. #define DELECMD "DELE"
  380. #define LASTCMD "LAST"
  381. #define RSETCMD "RSET"
  382. #define TOPCMD  "TOP"
  383. #define UIDLCMD "UIDL"
  384.  
  385. int DoCommand(int Socket)
  386. { char * Buffer;
  387.   char * Buffer2;
  388.   int Res;
  389.   char Password[19]={0};
  390.   FILE * fBox=NULL;
  391.   register unsigned long i;
  392.   long MsgNo, LastMsg=0;
  393.   char Ch;
  394.   int WasLF;
  395.   int sRes;
  396.   int Lines;
  397.   char * Arg1;
  398.   char * Arg2;
  399.   int LoggedIn=0;
  400.  
  401.   Buffer=(char*)malloc(2048);
  402.   if(Buffer==NULL) return(-1);
  403.  
  404.   Buffer2=(char*)malloc(2048);
  405.   if(Buffer2==NULL)
  406.     { free(Buffer);
  407.       return(-1);
  408.     }
  409.  
  410.   sprintf(Buffer2, "+OK POP3 server glad to meet you here ;) %s\x0D\x0A", ""/*TimeStamp*/);
  411.   sRes=write(Socket, Buffer2, strlen(Buffer2));
  412.   if(sRes<0)
  413.     { free(Buffer);
  414.       free(Buffer2);
  415.       return(-1);
  416.     }
  417.   do {
  418. /*Waiting for USER command*/
  419.        do { sRes=SkGetS(Socket, Buffer);
  420.             if(sRes!=0)
  421.               { free(Buffer);
  422.                 free(Buffer2);
  423.                 if(fBox) fclose(fBox);
  424.                 return(-1);
  425.               }
  426.             DelEndCRLF(Buffer);
  427.             DelSpaces(Buffer);
  428.  
  429.             if(memicmp(Buffer, USERCMD, strlen(USERCMD))==0)
  430.               { DelSpaces(&Buffer[strlen(USERCMD)]);
  431.                 strncpy(UserName, &Buffer[strlen(USERCMD)], 8);
  432.                 if(CheckUser(UserName))
  433.                   { sprintf(Buffer2, "+OK Hello, %s! Please remember your password!\x0D\x0A", UserName);
  434.                     sRes=write(Socket, Buffer2, strlen(Buffer2));
  435.                     if(sRes<0)
  436.                       { free(Buffer);
  437.                         free(Buffer2);
  438.                         return(-1);
  439.                       }
  440.                   }
  441.                  else
  442.                   { sprintf(Buffer2, "-ERR Don't know who is %s\x0D\x0A", UserName);
  443.                     sRes=write(Socket, Buffer2, strlen(Buffer2));
  444.                     if(sRes<0)
  445.                       { free(Buffer);
  446.                         free(Buffer2);
  447.                         return(-1);
  448.                       }
  449.                     UserName[0]=0;
  450.                     continue;
  451.                   }
  452.                 break;
  453.               }
  454.             if(memicmp(Buffer, QUITCMD, strlen(QUITCMD))==0)
  455.               { sprintf(Buffer2, "+OK POP3 server signing off\x0D\x0A");
  456.                 sRes=write(Socket, Buffer2, strlen(Buffer2));
  457.                 if(sRes<0)
  458.                   { free(Buffer);
  459.                     free(Buffer2);
  460.                     return(-1);
  461.                   }
  462.                 break;
  463.               }
  464.             sprintf(Buffer2, "-ERR Don't know how to do \"%s\"\x0D\x0A", Buffer);
  465.             sRes=write(Socket, Buffer2, strlen(Buffer2));
  466.             if(sRes<0)
  467.               { free(Buffer);
  468.                 free(Buffer2);
  469.                 return(-1);
  470.               }
  471.  
  472.           } while(1);
  473.        if(memicmp(Buffer, QUITCMD, strlen(QUITCMD))==0) return(0);
  474.  
  475. /*Get password and check it*/
  476.        LoggedIn=0;
  477.        sRes=SkGetS(Socket, Buffer);
  478.        if(sRes!=0)
  479.          { free(Buffer);
  480.            free(Buffer2);
  481.            if(fBox) fclose(fBox);
  482.            return(-1);
  483.          }
  484.        DelEndCRLF(Buffer);
  485.        DelSpaces(Buffer);
  486.      
  487.        if(memicmp(Buffer, PASSCMD, strlen(PASSCMD))==0)
  488.          { DelSpaces(&Buffer[strlen(PASSCMD)]);
  489.            strncpy(Password, &Buffer[strlen(PASSCMD)], 8);
  490.            if(!CheckPass(UserName, Password))
  491.              { sprintf(Buffer2, "-ERR Login failed\x0D\x0A");
  492.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  493.                if(sRes<0)
  494.                  { free(Buffer);
  495.                    free(Buffer2);
  496.                    return(-1);
  497.                  }
  498.  
  499.                Password[0]=0;
  500.                UserName[0]=0;
  501.                continue;
  502.              }
  503.             else
  504.              { sprintf(Buffer,  "%s%s",    BoxPath, UserName);
  505.                sprintf(Buffer2, "%s%s.mb", BoxPath, UserName);
  506. /*Open mailbox*/
  507.                if(rename(Buffer, Buffer2)<0)
  508.                  { sprintf(Buffer2, "-ERR Can't open maildrop for %s\x0D\x0A", UserName);
  509.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  510.                    if(sRes<0)
  511.                      { free(Buffer);
  512.                        free(Buffer2);
  513.                        return(-1);
  514.                      }
  515.  
  516.                    strcpy(Buffer, QUITCMD);
  517.                    break;
  518.                  }
  519.                
  520.                fBox=_fsopen(Buffer, "w+b", SH_DENYRW);
  521.                if(fBox==NULL)
  522.                  { sprintf(Buffer2, "-ERR Can't clear maildrop for %s\x0D\x0A", UserName);
  523.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  524.                    if(sRes<0)
  525.                      { free(Buffer);
  526.                        free(Buffer2);
  527.                        return(-1);
  528.                      }
  529.  
  530.                    strcpy(Buffer, QUITCMD);
  531.                    break;
  532.                  }
  533.                fclose(fBox);
  534.                fBox=_fsopen(Buffer2, "r+b", SH_DENYRW);
  535.                if(fBox==NULL)
  536.                  { sprintf(Buffer2, "-ERR Can't open maildrop for %s\x0D\x0A", UserName);
  537.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  538.                    if(sRes<0)
  539.                      { free(Buffer);
  540.                        free(Buffer2);
  541.                        return(-1);
  542.                      }
  543.  
  544.                    strcpy(Buffer, QUITCMD);
  545.                    break;
  546.                  }
  547.                sRes=RescanBox(fBox);
  548.                if(sRes)
  549.                  { sprintf(Buffer2, "-ERR Can't process maildrop for %s\x0D\x0A", UserName);
  550.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  551.                    if(sRes<0)
  552.                      { free(Buffer);
  553.                        free(Buffer2);
  554.                        if(fBox) fclose(fBox);
  555.                        return(-1);
  556.                      }
  557.  
  558.                    strcpy(Buffer, QUITCMD);
  559.                    break;
  560.                  }
  561.                signal(SIGHUP,   (void*)&CrashPack);
  562.                signal(SIGINT,   (void*)&CrashPack);
  563.                signal(SIGQUIT,  (void*)&CrashPack);
  564.                signal(SIGILL,   (void*)&CrashPack);
  565.                signal(SIGTRAP,  (void*)&CrashPack);
  566.                signal(SIGABRT,  (void*)&CrashPack);
  567.                signal(SIGEMT,   (void*)&CrashPack);
  568.                signal(SIGFPE,   (void*)&CrashPack);
  569.                signal(SIGBUS,   (void*)&CrashPack);
  570.                signal(SIGSEGV,  (void*)&CrashPack);
  571.                signal(SIGSYS,   (void*)&CrashPack);
  572.                signal(SIGPIPE,  (void*)&CrashPack);
  573.                signal(SIGTERM,  (void*)&CrashPack);
  574.                signal(SIGBREAK, (void*)&CrashPack);
  575.                sprintf(Buffer2, "+OK %s's maildrop has %lu messages (%lu octets)\x0D\x0A", UserName, uMsgCount, uTotalLen);
  576.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  577.                if(sRes<0)
  578.                  { free(Buffer);
  579.                    free(Buffer2);
  580.                    if(fBox) fclose(fBox);
  581.                    return(-1);
  582.                  }
  583.                LoggedIn=1;
  584.              }
  585.            break;
  586.          }
  587.        if(memicmp(Buffer, QUITCMD, strlen(QUITCMD))==0)
  588.          { sprintf(Buffer2, "+OK POP3 server signing off\x0D\x0A");
  589.            sRes=write(Socket, Buffer2, strlen(Buffer2));
  590.            if(sRes<0)
  591.              { free(Buffer);
  592.                free(Buffer2);
  593.                if(fBox) fclose(fBox);
  594.                return(-1);
  595.              }
  596.            break;
  597.          }
  598.        sprintf(Buffer2, "-ERR Don't know how to do \"%s\"\x0D\x0A", Buffer);
  599.        sRes=write(Socket, Buffer2, strlen(Buffer2));
  600.        if(sRes<0)
  601.          { free(Buffer);
  602.            free(Buffer2);
  603.            if(fBox) fclose(fBox);
  604.            return(-1);
  605.          }
  606.      } while(LoggedIn==0);
  607.   if(memicmp(Buffer, QUITCMD, strlen(QUITCMD))==0) return(0);
  608.  
  609.  
  610. /*Transaction state*/
  611.  
  612.   do { sRes=SkGetS(Socket, Buffer);
  613.        if(sRes!=0)
  614.          { free(Buffer);
  615.            free(Buffer2);
  616.            if(fBox) fclose(fBox);
  617.            PackBox(UserName, 0);
  618.            return(-1);
  619.          }
  620.        DelEndCRLF(Buffer);
  621.        DelSpaces(Buffer);
  622.  
  623.  
  624.  
  625. /*NOOP*/
  626.        if(memicmp(Buffer, NOCMD, strlen(NOCMD))==0)
  627.          { sprintf(Buffer2, "+OK It was so hard, but i've done it!\x0D\x0A");
  628.            sRes=write(Socket, Buffer2, strlen(Buffer2));
  629.            if(sRes<0)
  630.              { free(Buffer);
  631.                free(Buffer2);
  632.                if(fBox) fclose(fBox);
  633.                PackBox(UserName, 0);
  634.                return(-1);
  635.              }
  636.            continue;
  637.          }
  638.  
  639.  
  640.  
  641. /*STAT*/
  642.        if(memicmp(Buffer, STATCMD, strlen(STATCMD))==0)
  643.          { sprintf(Buffer2, "+OK %lu %lu\x0D\x0A", uMsgCount, uTotalLen);
  644.            sRes=write(Socket, Buffer2, strlen(Buffer2));
  645.            if(sRes<0)
  646.              { free(Buffer);
  647.                free(Buffer2);
  648.                if(fBox) fclose(fBox);
  649.                PackBox(UserName, 0);
  650.                return(-1);
  651.              }
  652.            continue;
  653.          }
  654.  
  655.  
  656.  
  657. /*LIST*/
  658.        if(memicmp(Buffer, LISTCMD, strlen(LISTCMD))==0)
  659.          { DelSpaces(&Buffer[strlen(LISTCMD)]);
  660.            if(IsEmpty(&Buffer[strlen(LISTCMD)]))
  661.              { sprintf(Buffer2, "+OK %lu messages (%lu octets)\x0D\x0A", uMsgCount, uTotalLen);
  662.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  663.                if(sRes<0)
  664.                  { free(Buffer);
  665.                    free(Buffer2);
  666.                    if(fBox) fclose(fBox);
  667.                    PackBox(UserName, 0);
  668.                    return(-1);
  669.                  }
  670.                for(i=0;i<msgCount;i++)
  671.                 { if(mBox[i].Deleted) continue;
  672.                   sprintf(Buffer2, "%lu %lu\x0D\x0A", i+1, mBox[i].Size);
  673.                   sRes=write(Socket, Buffer2, strlen(Buffer2));
  674.                   if(sRes<0)
  675.                     { free(Buffer);
  676.                       free(Buffer2);
  677.                       if(fBox) fclose(fBox);
  678.                       PackBox(UserName, 0);
  679.                       return(-1);
  680.                     }
  681.                 }
  682.                sprintf(Buffer2, ".\x0D\x0A");
  683.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  684.                if(sRes<0)
  685.                  { free(Buffer);
  686.                    free(Buffer2);
  687.                    if(fBox) fclose(fBox);
  688.                    PackBox(UserName, 0);
  689.                    return(-1);
  690.                  }
  691.              }
  692.             else
  693.              { MsgNo=atol(&Buffer[strlen(LISTCMD)])-1;
  694.                if((MsgNo>=msgCount) || (MsgNo<0))
  695.                  { sprintf(Buffer2, "-ERR no such message as %ld, just %lu messages in maildrop\x0D\x0A", MsgNo+1, msgCount);
  696.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  697.                    if(sRes<0)
  698.                      { free(Buffer);
  699.                        free(Buffer2);
  700.                        if(fBox) fclose(fBox);
  701.                        PackBox(UserName, 0);
  702.                        return(-1);
  703.                      }
  704.                  }
  705.                 else
  706.                  { if(mBox[MsgNo].Deleted)
  707.                      { sprintf(Buffer2, "-ERR Message %lu was killed\x0D\x0A", MsgNo+1);
  708.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  709.                        if(sRes<0)
  710.                          { free(Buffer);
  711.                            free(Buffer2);
  712.                            if(fBox) fclose(fBox);
  713.                            PackBox(UserName, 0);
  714.                            return(-1);
  715.                          }
  716.                      }
  717.                     else
  718.                      { sprintf(Buffer2, "+OK %lu %lu\x0D\x0A", MsgNo+1, mBox[MsgNo].Size);
  719.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  720.                        if(sRes<0)
  721.                          { free(Buffer);
  722.                            free(Buffer2);
  723.                            if(fBox) fclose(fBox);
  724.                            PackBox(UserName, 0);
  725.                            return(-1);
  726.                          }
  727.                        LastMsg=MsgNo+1;
  728.                      }
  729.                  }
  730.              }
  731.            continue;
  732.          }
  733.  
  734.  
  735.  
  736.  
  737.  
  738. /*UIDL*/
  739.        if(memicmp(Buffer, UIDLCMD, strlen(UIDLCMD))==0)
  740.          { DelSpaces(&Buffer[strlen(UIDLCMD)]);
  741.            if(IsEmpty(&Buffer[strlen(UIDLCMD)]))
  742.              { sprintf(Buffer2, "+OK There's message's names\x0D\x0A");
  743.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  744.                if(sRes<0)
  745.                  { free(Buffer);
  746.                    free(Buffer2);
  747.                    if(fBox) fclose(fBox);
  748.                    PackBox(UserName, 0);
  749.                    return(-1);
  750.                  }
  751.                for(i=0;i<msgCount;i++)
  752.                 { if(mBox[i].Deleted) continue;
  753.                   sprintf(Buffer2, "%lu %s\x0D\x0A", i+1, mBox[i].msgID);
  754.                   sRes=write(Socket, Buffer2, strlen(Buffer2));
  755.                   if(sRes<0)
  756.                     { free(Buffer);
  757.                       free(Buffer2);
  758.                       if(fBox) fclose(fBox);
  759.                       PackBox(UserName, 0);
  760.                       return(-1);
  761.                     }
  762.                 }
  763.                sprintf(Buffer2, ".\x0D\x0A");
  764.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  765.                if(sRes<0)
  766.                  { free(Buffer);
  767.                    free(Buffer2);
  768.                    if(fBox) fclose(fBox);
  769.                    PackBox(UserName, 0);
  770.                    return(-1);
  771.                  }
  772.              }
  773.             else
  774.              { MsgNo=atol(&Buffer[strlen(LISTCMD)])-1;
  775.                if((MsgNo>=msgCount) || (MsgNo<0))
  776.                  { sprintf(Buffer2, "-ERR no such message as %ld, just %lu messages in maildrop\x0D\x0A", MsgNo+1, msgCount);
  777.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  778.                    if(sRes<0)
  779.                      { free(Buffer);
  780.                        free(Buffer2);
  781.                        if(fBox) fclose(fBox);
  782.                        PackBox(UserName, 0);
  783.                        return(-1);
  784.                      }
  785.                  }
  786.                 else
  787.                  { if(mBox[MsgNo].Deleted)
  788.                      { sprintf(Buffer2, "-ERR Message %lu was killed\x0D\x0A", MsgNo+1);
  789.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  790.                        if(sRes<0)
  791.                          { free(Buffer);
  792.                            free(Buffer2);
  793.                            if(fBox) fclose(fBox);
  794.                            PackBox(UserName, 0);
  795.                            return(-1);
  796.                          }
  797.                      }
  798.                     else
  799.                      { sprintf(Buffer2, "+OK %lu %s\x0D\x0A", MsgNo+1, mBox[MsgNo].msgID);
  800.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  801.                        if(sRes<0)
  802.                          { free(Buffer);
  803.                            free(Buffer2);
  804.                            if(fBox) fclose(fBox);
  805.                            PackBox(UserName, 0);
  806.                            return(-1);
  807.                          }
  808.                        LastMsg=MsgNo+1;
  809.                      }
  810.                  }
  811.              }
  812.            continue;
  813.          }
  814.  
  815.  
  816.  
  817.  
  818. /*RETR*/
  819.        if(memicmp(Buffer, RETRCMD, strlen(RETRCMD))==0)
  820.          { DelSpaces(&Buffer[strlen(RETRCMD)]);
  821.            if(IsEmpty(&Buffer[strlen(RETRCMD)]))
  822.              { sprintf(Buffer2, "-ERR Don't know which message you want :~(\x0D\x0A");
  823.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  824.                if(sRes<0)
  825.                  { free(Buffer);
  826.                    free(Buffer2);
  827.                    if(fBox) fclose(fBox);
  828.                    PackBox(UserName, 0);
  829.                    return(-1);
  830.                  }
  831.              }
  832.             else
  833.              { MsgNo=atol(&Buffer[strlen(LISTCMD)])-1;
  834.                if((MsgNo>=msgCount) || (MsgNo<0))
  835.                  { sprintf(Buffer2, "-ERR no such message as %ld, just %lu messages in maildrop\x0D\x0A", MsgNo+1, msgCount);
  836.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  837.                    if(sRes<0)
  838.                      { free(Buffer);
  839.                        free(Buffer2);
  840.                        if(fBox) fclose(fBox);
  841.                        PackBox(UserName, 0);
  842.                        return(-1);
  843.                      }
  844.                  }
  845.                 else
  846.                  { if(mBox[MsgNo].Deleted)
  847.                      { sprintf(Buffer2, "-ERR Message %lu was killed\x0D\x0A", MsgNo+1);
  848.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  849.                        if(sRes<0)
  850.                          { free(Buffer);
  851.                            free(Buffer2);
  852.                            if(fBox) fclose(fBox);
  853.                            PackBox(UserName, 0);
  854.                            return(-1);
  855.                          }
  856.                      }
  857.                     else
  858.                      { sprintf(Buffer2, "+OK %u message's lines follow\x0D\x0A", Lines);
  859.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  860.                        if(sRes<0)
  861.                          { free(Buffer);
  862.                            free(Buffer2);
  863.                            if(fBox) fclose(fBox);
  864.                            PackBox(UserName, 0);
  865.                            return(-1);
  866.                          }
  867.                        fseek(fBox, mBox[MsgNo].Begin, SEEK_SET);
  868.                        WasLF=0;
  869.                        for(i=mBox[MsgNo].Begin;i<=mBox[MsgNo].End;i++)
  870.                         { if(fread(&Ch, 1, 1, fBox)!=1) break;
  871.                           if((WasLF) && (Ch=='.'))
  872.                             { sprintf(Buffer2, ".");
  873.                               sRes=write(Socket, Buffer2, strlen(Buffer2));
  874.                               if(sRes<0)
  875.                                 { free(Buffer);
  876.                                   free(Buffer2);
  877.                                   if(fBox) fclose(fBox);
  878.                                   PackBox(UserName, 0);
  879.                                   return(-1);
  880.                                 }
  881.                             }
  882.                           if(mBox[MsgNo].Is866)
  883.                             { if(i==mBox[MsgNo].cBeg)
  884.                                 { 
  885.                                   sprintf(Buffer2, "Content-Type: text/plain; charset=koi8-r\x0D\x0A");
  886.                                   i=mBox[MsgNo].cEnd;
  887.                                   fseek(fBox, i, SEEK_SET);
  888.                                   /*i--;*/
  889.                                 }
  890.                                else
  891.                                 { sprintf(Buffer2, "%c", cDOS2KOI(Ch));
  892.                                 }
  893.                             }
  894.                            else 
  895.                             { sprintf(Buffer2, "%c", Ch);
  896.                             }
  897.                           sRes=write(Socket, Buffer2, strlen(Buffer2));
  898.                           if(sRes<0)
  899.                             { free(Buffer);
  900.                               free(Buffer2);
  901.                               if(fBox) fclose(fBox);
  902.                               PackBox(UserName, 0);
  903.                               return(-1);
  904.                             }
  905.                           if((Ch==0x0D) || (Ch==0x0A)) WasLF=1;
  906.                            else WasLF=0;
  907.                         }
  908.                        sprintf(Buffer2, ".\x0D\x0A");
  909.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  910.                        if(sRes<0)
  911.                          { free(Buffer);
  912.                            free(Buffer2);
  913.                            if(fBox) fclose(fBox);
  914.                            PackBox(UserName, 0);
  915.                            return(-1);
  916.                          }
  917.                        mBox[MsgNo].Status=ROld;
  918.                        LastMsg=MsgNo+1;
  919.                      }
  920.                  }
  921.              }
  922.            continue;
  923.          }
  924.  
  925.  
  926.  
  927. /*TOP*/
  928.        if(memicmp(Buffer, TOPCMD, strlen(TOPCMD))==0)
  929.          { Lines=0;
  930.            MsgNo=0;
  931.            Arg1=&Buffer[strlen(TOPCMD)];
  932.            DelSpaces(Arg1);
  933.            for(i=0;i<strlen(Arg1);i++)
  934.             { if(IsSpace(Arg1[i])) break;
  935.             }
  936.            if(Arg1[i]==0) 
  937.              { Arg2=&Arg1[i];
  938.              }
  939.             else
  940.              { Arg2=&Arg1[i+1];
  941.                Arg1[i]=0;
  942.              }
  943.            DelSpaces(Arg1);
  944.            DelSpaces(Arg2);
  945.            MsgNo=atol(Arg1)-1;
  946.            Lines=atoi(Arg2);
  947.  
  948.            if(IsEmpty(Arg1))
  949.              { sprintf(Buffer2, "-ERR Don't know which message you want :~(\x0D\x0A");
  950.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  951.                if(sRes<0)
  952.                  { free(Buffer);
  953.                    free(Buffer2);
  954.                    if(fBox) fclose(fBox);
  955.                    PackBox(UserName, 0);
  956.                    return(-1);
  957.                  }
  958.              }
  959.             else
  960.              { if((MsgNo>=msgCount) || (MsgNo<0))
  961.                  { sprintf(Buffer2, "-ERR no such message as %ld, just %lu messages in maildrop\x0D\x0A", MsgNo+1, msgCount);
  962.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  963.                    if(sRes<0)
  964.                      { free(Buffer);
  965.                        free(Buffer2);
  966.                        if(fBox) fclose(fBox);
  967.                        PackBox(UserName, 0);
  968.                        return(-1);
  969.                      }
  970.                  }
  971.                 else
  972.                  { if(mBox[MsgNo].Deleted)
  973.                      { sprintf(Buffer2, "-ERR Message %lu was killed\x0D\x0A", MsgNo+1);
  974.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  975.                        if(sRes<0)
  976.                          { free(Buffer);
  977.                            free(Buffer2);
  978.                            if(fBox) fclose(fBox);
  979.                            PackBox(UserName, 0);
  980.                            return(-1);
  981.                          }
  982.                      }
  983.                     else
  984.                      { if(Lines<0)
  985.                          { sprintf(Buffer2, "-ERR Value %d is invalid for lines count\x0D\x0A", Lines);
  986.                            sRes=write(Socket, Buffer2, strlen(Buffer2));
  987.                            if(sRes<0)
  988.                              { free(Buffer);
  989.                                free(Buffer2);
  990.                                if(fBox) fclose(fBox);
  991.                                PackBox(UserName, 0);
  992.                                return(-1);
  993.                              }
  994.                          }
  995.                         else
  996.                          { sprintf(Buffer2, "+OK %u message's lines follow\x0D\x0A", Lines);
  997.                            sRes=write(Socket, Buffer2, strlen(Buffer2));
  998.                            if(sRes<0)
  999.                              { free(Buffer);
  1000.                                free(Buffer2);
  1001.                                if(fBox) fclose(fBox);
  1002.                                PackBox(UserName, 0);
  1003.                                return(-1);
  1004.                              }
  1005.                            fseek(fBox, mBox[MsgNo].Begin, SEEK_SET);
  1006.                            WasLF=0;
  1007.                            for(i=mBox[MsgNo].Begin;i<=mBox[MsgNo].End;i++)
  1008.                             { if(fread(&Ch, 1, 1, fBox)!=1) break;
  1009.                               if((WasLF) && (Ch=='.'))
  1010.                                 { sprintf(Buffer2, ".");
  1011.                                   sRes=write(Socket, Buffer2, strlen(Buffer2));
  1012.                                   if(sRes<0)
  1013.                                     { free(Buffer);
  1014.                                       free(Buffer2);
  1015.                                       if(fBox) fclose(fBox);
  1016.                                       PackBox(UserName, 0);
  1017.                                       return(-1);
  1018.                                     }
  1019.                                 }
  1020.                               if(mBox[MsgNo].Is866)
  1021.                                 { if(i==mBox[MsgNo].cBeg)
  1022.                                     { 
  1023.                                       sprintf(Buffer2, "Content-Type: text/plain; charset=koi8-r\x0D\x0A");
  1024.                                       i=mBox[MsgNo].cEnd;
  1025.                                       fseek(fBox, i, SEEK_SET);
  1026.                                       /*i--;*/
  1027.                                     }
  1028.                                    else
  1029.                                     { sprintf(Buffer2, "%c", cDOS2KOI(Ch));
  1030.                                     }
  1031.                                 }
  1032.                                else 
  1033.                                 { sprintf(Buffer2, "%c", Ch);
  1034.                                 }
  1035.                               sRes=write(Socket, Buffer2, strlen(Buffer2));
  1036.                               if(sRes<0)
  1037.                                 { free(Buffer);
  1038.                                   free(Buffer2);
  1039.                                   if(fBox) fclose(fBox);
  1040.                                   PackBox(UserName, 0);
  1041.                                   return(-1);
  1042.                                 }
  1043.                               if(Ch==0x0A) 
  1044.                                 { WasLF=1;
  1045.                                   if(i>mBox[MsgNo].hEnd) 
  1046.                                     { Lines--;
  1047.                                     }
  1048.                                 }
  1049.                                else 
  1050.                                 { WasLF=0;
  1051.                                 }
  1052.                               if(Lines<0) break;
  1053.                             }
  1054.                            sprintf(Buffer2, ".\x0D\x0A");
  1055.                            sRes=write(Socket, Buffer2, strlen(Buffer2));
  1056.                            if(sRes<0)
  1057.                              { free(Buffer);
  1058.                                free(Buffer2);
  1059.                                if(fBox) fclose(fBox);
  1060.                                PackBox(UserName, 0);
  1061.                                return(-1);
  1062.                              }
  1063.                            mBox[MsgNo].Status=ROld;
  1064.                            LastMsg=MsgNo+1;
  1065.                          }
  1066.                      }
  1067.                  }
  1068.              }
  1069.            continue;
  1070.          }
  1071.  
  1072.  
  1073.  
  1074. /*DELE*/
  1075.        if(memicmp(Buffer, DELECMD, strlen(DELECMD))==0)
  1076.          { DelSpaces(&Buffer[strlen(DELECMD)]);
  1077.            if(IsEmpty(&Buffer[strlen(DELECMD)]))
  1078.              { sprintf(Buffer2, "-ERR Don't know which message you want to delete\x0D\x0A");
  1079.                sRes=write(Socket, Buffer2, strlen(Buffer2));
  1080.                if(sRes<0)
  1081.                  { free(Buffer);
  1082.                    free(Buffer2);
  1083.                    if(fBox) fclose(fBox);
  1084.                    PackBox(UserName, 0);
  1085.                    return(-1);
  1086.                  }
  1087.              }
  1088.             else
  1089.              { MsgNo=atol(&Buffer[strlen(LISTCMD)])-1;
  1090.                if((MsgNo>=msgCount) || (MsgNo<0))
  1091.                  { sprintf(Buffer2, "-ERR no such message as %ld, just %lu messages in maildrop\x0D\x0A", MsgNo, msgCount);
  1092.                    sRes=write(Socket, Buffer2, strlen(Buffer2));
  1093.                    if(sRes<0)
  1094.                      { free(Buffer);
  1095.                        free(Buffer2);
  1096.                        if(fBox) fclose(fBox);
  1097.                        PackBox(UserName, 0);
  1098.                        return(-1);
  1099.                      }
  1100.                  }
  1101.                 else
  1102.                  { if(mBox[MsgNo].Deleted)
  1103.                      { sprintf(Buffer2, "-ERR Pervert! You can't kill one message twice\x0D\x0A");
  1104.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  1105.                        if(sRes<0)
  1106.                          { free(Buffer);
  1107.                            free(Buffer2);
  1108.                            if(fBox) fclose(fBox);
  1109.                            PackBox(UserName, 0);
  1110.                            return(-1);
  1111.                          }
  1112.                      }
  1113.                     else
  1114.                      { sprintf(Buffer2, "+OK message %u killed\x0D\x0A", MsgNo+1);
  1115.                        sRes=write(Socket, Buffer2, strlen(Buffer2));
  1116.                        if(sRes<0)
  1117.                          { free(Buffer);
  1118.                            free(Buffer2);
  1119.                            if(fBox) fclose(fBox);
  1120.                            PackBox(UserName, 0);
  1121.                            return(-1);
  1122.                          }
  1123.                        mBox[MsgNo].Deleted=1;
  1124.                        uMsgCount--;
  1125.                        uTotalLen-=mBox[MsgNo].Size;
  1126.                      }
  1127.                  }
  1128.              }
  1129.            continue;
  1130.          }
  1131.  
  1132.  
  1133.  
  1134. /*LAST*/
  1135.        if(memicmp(Buffer, LASTCMD, strlen(LASTCMD))==0)
  1136.          { if(mBox[LastMsg-1].Deleted) LastMsg=0;
  1137.            if(LastMsg>msgCount) LastMsg=0;
  1138.            sprintf(Buffer2, "+OK %lu\x0D\x0A", LastMsg);
  1139.            sRes=write(Socket, Buffer2, strlen(Buffer2));
  1140.            if(sRes<0)
  1141.              { free(Buffer);
  1142.                free(Buffer2);
  1143.                if(fBox) fclose(fBox);
  1144.                PackBox(UserName, 0);
  1145.                return(-1);
  1146.              }
  1147.            continue;
  1148.          }
  1149.  
  1150.  
  1151.  
  1152. /*RSET*/
  1153.        if(memicmp(Buffer, RSETCMD, strlen(RSETCMD))==0)
  1154.          { for(i=0;i<msgCount;i++)
  1155.             mBox[i].Deleted=0;
  1156.            uMsgCount=msgCount;
  1157.            uTotalLen=TotalLen;
  1158.            continue;
  1159.          }
  1160.  
  1161.  
  1162.  
  1163. /*QUIT*/
  1164.        if(memicmp(Buffer, QUITCMD, strlen(QUITCMD))==0)
  1165.          { break;
  1166.          }
  1167.        sprintf(Buffer2, "-ERR Don't know how to do \"%s\"\x0D\x0A", Buffer);
  1168.        sRes=write(Socket, Buffer2, strlen(Buffer2));
  1169.        if(sRes<0)
  1170.          { free(Buffer);
  1171.            free(Buffer2);
  1172.            if(fBox) fclose(fBox);
  1173.            PackBox(UserName, 0);
  1174.            return(-1);
  1175.          }
  1176.      } while(1);
  1177.  
  1178.   free(Buffer);
  1179.   free(Buffer2);
  1180.  
  1181.   if(fBox!=NULL) fclose(fBox);
  1182.   if(PackBox(UserName, 1)==0)
  1183.     { sprintf(Buffer2, "+OK %lu messages (%lu octets) remains\x0D\x0A", uMsgCount, uTotalLen);
  1184.       sRes=write(Socket, Buffer2, strlen(Buffer2));
  1185.       if(sRes<0)
  1186.         { free(Buffer);
  1187.           free(Buffer2);
  1188.           if(fBox) fclose(fBox);
  1189.           return(-1);
  1190.         }
  1191.     }
  1192.    else
  1193.     { sprintf(Buffer2, "-ERR All changes has been discarded :(\x0D\x0A");
  1194.       sRes=write(Socket, Buffer2, strlen(Buffer2));
  1195.       if(sRes<0)
  1196.         { free(Buffer);
  1197.           free(Buffer2);
  1198.           if(fBox) fclose(fBox);
  1199.           return(-1);
  1200.         }
  1201.     }
  1202.  
  1203.   for(i=0;i<msgCount;i++)
  1204.    { free(mBox[i].msgID);
  1205.    }
  1206.   if(mBox!=NULL) free(mBox);
  1207.  
  1208.   return(Res);
  1209. }
  1210.  
  1211.  
  1212. char MyName[512];
  1213. int main (int ArgC, char * ArgV[])
  1214. { int Res;
  1215.   struct hostent MyHost;
  1216.   struct in_addr MyAddr;
  1217.   unsigned long * lMyAddr;
  1218.  
  1219.   fprintf(stderr,"vPopper/2. (C)'97 VR vik@lada.kiev.ua 2:463/262 2:463/278\n");
  1220.   if((ArgC>1) && (ArgV[1][1]=='?'))
  1221.     { fprintf(stderr, "POP3 server/2.\nUsage : %s [mailboxes path [passwd file]]\n", ArgV[0]);
  1222.       fprintf(stderr, "Default values : mailbox path = ./\n"
  1223.              "                 passwd file  = passwd\n");
  1224.       return(0);
  1225.     }
  1226.   if(ArgC>1)
  1227.     { strncpy(BoxPath, ArgV[1], 510);
  1228.       if((BoxPath[strlen(BoxPath)-1]!='\\') && (BoxPath[strlen(BoxPath)-1]!='/'))
  1229.         { strcat(BoxPath, "\\");
  1230.         }
  1231.     }
  1232.   if(ArgC>2)
  1233.     { strncpy(PwdPath, ArgV[2], 511);
  1234.     }
  1235.  
  1236.   MyName[0]=0;
  1237.   gethostname(MyName, 511);
  1238.  
  1239. /*  memcpy(&MyHost, gethostbyname(MyName), sizeof(MyHost));*/
  1240.  
  1241. /*  memcpy(&MyAddr.s_addr, MyHost->h_addr_list[0], MyHost->h_length);*/
  1242. /*  fprintf(stderr, "POP3@%s [%s]\n", MyName, inet_ntoa(MyAddr));*/
  1243.   fprintf(stderr, "POP3@%s\n", MyName);
  1244.   fprintf(stderr, "Using [%s] as passwd\nand   [%s] as mail/boxes\n", PwdPath, BoxPath);
  1245.  
  1246.   fprintf(stderr, "Initializing\n");
  1247.   WaitConn();
  1248.  
  1249.   fprintf(stderr, " \nTerminated\n\n");
  1250.   return(0);
  1251. }
  1252.  
  1253.  
  1254.  
  1255.