home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / winsock / wsmtpd16 / wsmtpsrv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  45.2 KB  |  1,690 lines
  1. /* WSMTPSrv.C - Windows SMTP Server
  2.     - WinSock V1.1 required
  3.  
  4.    Author: Ian Blenke
  5.  
  6. Ian Blenke cannot be held responsible for damages, expressed or implied, for
  7. the use of this software. No commercial use can be made of this product
  8. without the consent of the author. No profit of any kind can be made on the
  9. sale or distribution of this program. If you wish to distribute this program
  10. with other samples of WinSock programming, you must first contact the author
  11. so that he can keep accurate records of its usage. If you write any programs
  12. based on this source code, you may not sell them for any profit without the
  13. written consent of the author. If you incorporate this source code into a
  14. public domain program, all the author requires is a notification that "part
  15. of the code was written by Ian Blenke" and some form of notification that
  16. his name was used in the public domain software distribution. This does not
  17. represent a contract on the part of the author. If any issues cannot clearly
  18. be resolved by reading this text, immediately contact the author.
  19.  
  20. I don't like such agreements, but in today's world of lawyers and lawbreakers
  21. I have little other choice. Enjoy!
  22. */
  23.  
  24. #include "WSMTPSrv.h"
  25.  
  26. /* DEBUGIT();
  27.     Purpose: To print debugging messages to the debugging window/console.
  28. */
  29. /*VOID DEBUGIT( LPSTR lpString)
  30. {
  31.  static char szErrors[256];
  32.  
  33.  wsprintf((LPSTR)szErrors, (LPSTR)"WSMTPD: %s\n\r", lpString);
  34.  OutputDebugString( (LPSTR)szErrors );
  35. }  /**/
  36.  
  37. /* WinMain();
  38.     Purpose: The entry point for our app.
  39. */
  40. UINT PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  41.                     LPSTR lpszCmdLine, int nCmdShow)
  42. {
  43.  MSG        msg;
  44.  WORD       wVersionRequested;
  45.  WSADATA    wsaData;
  46.  DLGPROC    dlgProc;
  47.  WNDCLASS   wndclass;
  48.  HICON      hIcon;
  49.  
  50.  hInst=hInstance;
  51.  lstrcpy((LPSTR)szAppName, (LPSTR)APP_NAME);
  52.  
  53.  //DEBUGIT("WinMain() Begin");
  54.  
  55.  if(hPrevInstance)
  56.  {
  57.   smtpError(IDS_PREV_INSTANCE);
  58.   return(NULL);
  59.  }
  60.  
  61.  wVersionRequested=WSVERSION;
  62.  if(WSAStartup(wVersionRequested, (LPWSADATA)&wsaData))
  63.  {
  64.   smtpError(IDS_NO_WINSOCK);
  65.   return(NULL);
  66.  }
  67.  if((LOBYTE(wsaData.wVersion)!=1) ||
  68.     (HIBYTE(wsaData.wVersion)!=1))
  69.  {
  70.   smtpError(IDS_BAD_VERSION);
  71.   WSACleanup();
  72.   //DEBUGIT("WinSock version is not v1.1");
  73.   return(NULL);
  74.  }
  75.  
  76.  #ifdef USE_3D
  77.   Ctl3dRegister(hInst);
  78.   Ctl3dAutoSubclass(hInst);
  79.  #endif /*USE_3D*/
  80.  
  81.  
  82.  dlgProc=(DLGPROC)MakeProcInstance((FARPROC)DlgProc, hInst);
  83.  hWndDlg=CreateDialog(hInst, (LPSTR)dlgWSMTPSRV,
  84.               GetDesktopWindow(), dlgProc);
  85.  
  86.  if(!hWndDlg)
  87.  {
  88.   smtpError(IDS_SMTP_INIT);
  89. #ifdef USE_3D
  90.   Ctl3dUnregister(hInst);
  91. #endif // USE_3D
  92.   WSACleanup();
  93.   //DEBUGIT("Modeless dialog window could not be opened");
  94.   return(NULL);
  95.  }
  96.  
  97.  hIcon=LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICONEMPTY));
  98.  
  99.  if(hIcon != NULL)
  100.  {
  101.   SetProp(hWndDlg, "icon", hIcon);
  102.  }
  103. // else DEBUGIT("IDI_ICONEMPTY Resource not found");
  104.  
  105.  SetClassWord(hWndDlg, GCW_HICON, NULL);
  106.  
  107.  ShowWindow(hWndDlg, nCmdShow);
  108.  
  109.  //DEBUGIT("Starting smtpInit");
  110.  
  111.  if(smtpInit(INI_FILE))
  112.  {
  113.   DestroyWindow(hWndDlg);
  114. //  smtpError(IDS_SMTP_INIT);
  115. #ifdef USE_3D
  116.   Ctl3dUnregister(hInst);
  117. #endif /* USE_3D */
  118.   WSACleanup();
  119.   //DEBUGIT("Daemon initialization error");
  120.   return(NULL);
  121.  }
  122.  
  123.  while(GetMessage(&msg, NULL, 0, 0))
  124.  {
  125.   if(!IsDialogMessage(hWndDlg, &msg))
  126.   {
  127.    TranslateMessage(&msg);
  128.    DispatchMessage(&msg);
  129.   }
  130.  }
  131.  
  132. #ifdef USE_3D
  133.  Ctl3dUnregister(hInst);
  134. #endif
  135.  
  136.   WSACleanup();
  137.  
  138.   //DEBUGIT("WinMain() End");
  139.  
  140.   return msg.wParam;
  141. } /* WinMain */
  142.  
  143.  
  144. /* LRESULT CALLBACK DlgProc(HWND, UINT, WPARAM);
  145.     Purpose: To handle the main dialog user intervention.
  146.     Given/Returns: Standard Dialog procedure
  147. */
  148. LRESULT CALLBACK DlgProc(HWND hWnd, UINT Msg, WPARAM wParam,
  149.                       LPARAM lParam)
  150. {
  151.  HICON hIcon;
  152.  
  153.  switch(Msg)
  154.  {
  155.   case WM_INITDIALOG:
  156.     {
  157.      if(iLogLevel==LOG_LOW)
  158.      {
  159.       CheckRadioButton(hWnd, IDR_NORMAL, IDR_DEBUG,
  160.                        IDR_NORMAL);
  161.      }
  162.      else
  163.      {
  164.       CheckRadioButton(hWnd, IDR_NORMAL, IDR_DEBUG,
  165.                        IDR_DEBUG);
  166.      }
  167.      SetDlgItemText(hWnd, IDE_PATH, (LPSTR)szLocalMailPath);
  168.      SetDlgItemText(hWnd, IDE_HOSTNAME, (LPSTR)szLocalHostName);
  169.      return(TRUE);
  170.     }
  171.     break;
  172.  
  173.   case WM_COMMAND:
  174.   {
  175.    switch(wParam)
  176.    {
  177.     case IDR_NORMAL:
  178.     {
  179.      iLogLevel=LOG_LOW;
  180.      return(TRUE);
  181.     }
  182.  
  183.     case IDR_DEBUG:
  184.     {
  185.      iLogLevel=LOG_HIGH;
  186.      return(TRUE);
  187.     }
  188.  
  189.     case IDB_PATH:
  190.     {
  191.      int iError;
  192.      DWORD dwError;
  193.  
  194.      if(iError=GetOpenFileName((OPENFILENAME FAR *)&ofnMailPath))
  195.      {
  196.       WritePrivateProfileString(SECTION_MAIN, ENTRY_MAILPATH,
  197.                          (LPSTR)szLocalMailPath,
  198.                          (LPSTR)INI_FILE);
  199.       SetDlgItemText(hWndDlg, IDE_PATH, (LPSTR)szLocalMailPath);
  200.      }
  201.      else
  202.      {          // Debugging
  203.       dwError=CommDlgExtendedError();
  204.      }
  205.      return(TRUE);
  206.     }
  207.    }
  208.    break;
  209.  
  210.     // All of this, for a changing Icon - Sheesh
  211.    case WM_PAINT:
  212.    {
  213.     if(IsIconic(hWndDlg))
  214.     {
  215.      PAINTSTRUCT ps;
  216.      HDC hDC;
  217.      DWORD dwOrg;
  218.      HICON hIcon = GetProp(hWndDlg, "icon");
  219.  
  220.      if(hIcon != NULL)
  221.      {
  222.       hDC=BeginPaint(hWndDlg, &ps);
  223.  
  224.       dwOrg = GetWindowOrg(hDC);
  225.       SendMessage(hWndDlg, WM_ICONERASEBKGND, hDC, 0L);
  226.       DrawIcon(hDC, LOWORD(dwOrg)+2, HIWORD(dwOrg)+2, hIcon);
  227.       EndPaint(hWndDlg, &ps);
  228.       return(TRUE);
  229.      }
  230.     }
  231.    }
  232.    break;
  233.  
  234.    case WM_ERASEBKGND:
  235.    {
  236.     if(IsIconic(hWndDlg)) return(TRUE);
  237.     else return(FALSE);
  238.    }
  239.  
  240.    case WM_CLOSE:
  241.    {
  242.     RemoveProp(hWndDlg, "icon");
  243.     netClose();
  244.     DestroyWindow(hWndDlg);
  245.     return(TRUE);
  246.    }
  247.    break;
  248.  
  249.    case WM_QUERYDRAGICON:
  250.    {
  251.     HICON hIcon;
  252.  
  253.     return(hIcon = GetProp(hWndDlg, "icon"));
  254.    }
  255.  
  256.    /* Periodically check for mail until user reads it */
  257.    case WM_TIMER:
  258.    {
  259.     if(!smtpMailCheck(szLocalMailPath))
  260.     {
  261.      KillTimer(hWndDlg, (UINT)wParam);
  262.      SetWindowText(hWndDlg, (LPSTR)STRING_NOMAIL);
  263.     }
  264.     else
  265.     {
  266.      SetWindowText(hWndDlg, (LPSTR)STRING_HAVEMAIL);
  267.     }
  268.     return(TRUE);
  269.    }
  270.    break;
  271.  
  272.    /* Don't let the user ReSize/Maximize the window! */
  273.    case WM_INITMENUPOPUP:
  274.    {
  275.     if(HIWORD(lParam))
  276.     {
  277.      HMENU hSystemMenu;
  278.  
  279.      hSystemMenu = GetSystemMenu(hWndDlg, FALSE);
  280.      EnableMenuItem(hSystemMenu, SC_SIZE, MF_GRAYED);
  281.      EnableMenuItem(hSystemMenu, SC_MAXIMIZE, MF_GRAYED);
  282.     }
  283.    }
  284.    break;
  285.  
  286.    case WM_DESTROY:
  287.    {
  288.     PostQuitMessage(0);
  289.     return(TRUE);
  290.    }
  291.    break;
  292.   }
  293.  }
  294.  return(FALSE);
  295. } /* dlgProc() */
  296.  
  297.  
  298. /* void smtpError(int);
  299.     Purpose: To print out a resource string with parameters
  300.     Given:   ResourceID of format string, and variable arguements.
  301.     Returns: Nothing.
  302. */
  303. void smtpError(int ResourceID, ...)
  304. {
  305.  char szString[MAXLINE];
  306.  char szBuffer[MAXLINE];
  307.  va_list vaArgs;
  308.  LPSTR lpArg1, lpArg2;
  309.  
  310.  va_start( vaArgs, ResourceID);
  311.  lpArg1 = va_arg( vaArgs, LPSTR);
  312.  lpArg2 = va_arg( vaArgs, LPSTR);
  313.  
  314.  if(IsIconic(hWndDlg))          // If in server mode, no modals!
  315.  {
  316.   smtpLog(LOG_HIGH | LOG_TIME, ResourceID, vaArgs);
  317.   return;
  318.  }
  319.  
  320.  if(!LoadString(hInst, ResourceID, (LPSTR)szString,
  321.                 MAXLINE))
  322.     return;
  323.  
  324.  wsprintf((LPSTR)szBuffer, (LPSTR)szString, lpArg1, lpArg2);
  325.  
  326.  //DEBUGIT(szBuffer);
  327.  MessageBeep(MB_ICONEXCLAMATION);
  328.  MessageBox(NULL, (LPSTR)szBuffer, (LPSTR)szAppName,
  329.             MB_OK | MB_ICONEXCLAMATION);
  330.  return;
  331. } /* smtpError */
  332.  
  333.  
  334. /* void smtpLog(int, ...);
  335.     Purpose: To print an item in the "log" listbox.
  336.     Given:   Resource ID and variable args.
  337.     Returns: Nothing
  338. */
  339. void smtpLog(int iLevel, int ResourceID, ...)
  340. {
  341.  char szString[MAXLINE];
  342.  char szLine[MAXLINE];
  343.  char szTime[30];
  344.  LPSTR lpArg1, lpArg2;
  345.  va_list vaArgs;
  346.  DWORD dwCount;
  347.  
  348.  if((iLevel&(LOG_TIME-1))<iLogLevel) return;          // Only log what we want
  349.  
  350.  va_start( vaArgs, ResourceID);
  351.  
  352.  if(!LoadString(hInst, ResourceID, (LPSTR)szLine, MAXLINE))
  353.     return;
  354.  
  355.  lpArg1=va_arg(vaArgs, LPSTR);
  356.  lpArg2=va_arg(vaArgs, LPSTR);
  357.  
  358.  wsprintf((LPSTR)szString, (LPSTR)szLine, lpArg1, lpArg2);
  359.  
  360.  if(iLevel&LOG_TIME)
  361.  {
  362.   netGetTimeAndDate((LPSTR)szTime, sizeof(szTime));
  363.   wsprintf((LPSTR)szLine, "%s> %s", (LPSTR)szTime, (LPSTR)szString);
  364.  }
  365.  else
  366.  {
  367.   lstrcpy((LPSTR)szLine, (LPSTR)szString);
  368.  }
  369.  //DEBUGIT(szLine);
  370.  SendDlgItemMessage(hWndDlg, IDL_LOG, LB_ADDSTRING, 0,
  371.                     (LPARAM)(LPCSTR)szLine);
  372.  
  373.  dwCount=SendDlgItemMessage(hWndDlg, IDL_LOG, LB_GETCOUNT, 0, 0l);
  374.  if(dwCount>MAXITEMS)
  375.  {
  376.   SendDlgItemMessage(hWndDlg, IDL_LOG, LB_RESETCONTENT, 0, 0l);
  377.   wsprintf((LPSTR)szLine, "%s> Reset Log - over %d lines", (LPSTR)szTime,
  378.            MAXITEMS);
  379.   //DEBUGIT(szLine);
  380.   SendDlgItemMessage(hWndDlg, IDL_LOG, LB_ADDSTRING, 0,
  381.                     (LPARAM)(LPCSTR)szLine);
  382.  }
  383. } /* smtpLog */
  384.  
  385.  
  386. /* BOOL smtpInit(PSTR);
  387.     Purpose: To setup the SMTP protocol and structures.
  388.     Given:   A filename.
  389.     Returns: TRUE on error, FALSE if not.
  390. */
  391. BOOL smtpInit(PSTR pFilename)
  392. {
  393.  LPSTR lpString;
  394.  HANDLE hMenu;
  395.  
  396.  ofnMailPath.lStructSize=sizeof(ofnMailPath);
  397.  ofnMailPath.hwndOwner=hWndDlg;
  398.  ofnMailPath.hInstance=hInst;
  399.  szMailPathFilter[0]='\0';
  400.  LoadString(hInst, IDS_FILTER,
  401.             (LPSTR)szMailPathFilter, sizeof(szMailPathFilter));
  402.  ofnMailPath.lpstrFilter=(LPSTR)szMailPathFilter;
  403.  ofnMailPath.nFilterIndex=2;
  404.  ofnMailPath.lpstrCustomFilter=(LPSTR)NULL;
  405.  ofnMailPath.lpstrFile=(LPSTR)szLocalMailPath;
  406.  ofnMailPath.nMaxFile=sizeof(szLocalMailPath);
  407.  ofnMailPath.lpstrFileTitle=(LPSTR)NULL;
  408.  ofnMailPath.lpstrInitialDir=(LPSTR)NULL;
  409.  ofnMailPath.lpstrTitle=(LPSTR)szAppName;
  410.  ofnMailPath.Flags=OFN_CREATEPROMPT | OFN_NOREADONLYRETURN;
  411.  ofnMailPath.lpstrDefExt=(LPSTR)NULL;
  412.  
  413.     // Initialize network windows & such
  414.  if(netInit()) return(TRUE);
  415.  
  416.  iLogLevel=GetPrivateProfileInt(SECTION_MAIN, ENTRY_DEBUG,
  417.                                 LOG_HIGH, (LPSTR)pFilename);
  418.  GetPrivateProfileString(SECTION_MAIN, ENTRY_MAILPATH,
  419.                          (LPSTR)DEFAULTMAILFILE,
  420.                          (LPSTR)szLocalMailPath,
  421.                          sizeof(szLocalMailPath),
  422.                          (LPSTR)pFilename);
  423.  
  424.  if(iLogLevel==LOG_LOW)
  425.  {
  426.   CheckRadioButton(hWndDlg, IDR_NORMAL, IDR_DEBUG,
  427.                    IDR_NORMAL);
  428.  }
  429.  else
  430.  {
  431.   CheckRadioButton(hWndDlg, IDR_NORMAL, IDR_DEBUG,
  432.                    IDR_DEBUG);
  433.  }
  434.  SetDlgItemText(hWndDlg, IDE_PATH, (LPSTR)szLocalMailPath);
  435.  SetDlgItemText(hWndDlg, IDE_HOSTNAME, (LPSTR)szLocalHostName);
  436.  
  437.  return(FALSE);
  438. } /* smtpInit */
  439.  
  440.  
  441. /* BOOL smtpServer(LPSMTPCLIENT);
  442.     Purpose: To be the heart & soul of the SMTP
  443.              server.
  444.     Given:   pointer to the Client that was active.
  445.     Returns: FALSE
  446.     Notes:   This is the heart & soul of the beast.
  447. */
  448. BOOL smtpServer(LPSMTPCLIENT lpClient)
  449. {
  450.  static char szLine[MAXSNDBUFF];       // These are still holdovers
  451.  static char szPaddedLine[MAXSNDBUFF]; // They should be replaced
  452.  PSTR pLine;
  453.  int iDebug;
  454.  BOOL bCmdOk;
  455.  
  456.  if(!lpClient) return(TRUE);
  457.  
  458.  //DEBUGIT("smtpServer() Begin");
  459.  
  460.     // 8BITMIME hack
  461.  if((lpClient->iExtendedFlags & ESMTP_8BITMIME) &&
  462.     (lpClient->iState == STATE_WAIT_FOR_DOT))
  463.  {
  464.   //DEBUGIT("ESMTP_8BITMIME && STATE_WAIT_FOR_DOT");
  465.   while(clientReceiveBlock(lpClient, szLine, sizeof(szLine)))
  466.   {
  467.    if(lpClient->hfFile!=HFILE_ERROR)
  468.    {
  469.     iDebug=_lwrite(lpClient->hfFile,
  470.             (LPSTR)szLine, lstrlen((LPSTR)szLine));
  471.    }
  472.   } // While there is data
  473.  } // If in DATA state with 8BITMIME active.
  474.  
  475.     // This is a hack for when a client QUIT's.
  476.  bConnectionQuit=FALSE;
  477.  
  478.     // Get as many lines as are waiting
  479.  while(!bConnectionQuit &&
  480.        (clientReceiveLine(lpClient, szLine, sizeof(szLine)) >= 0))
  481.  {
  482.     // Treat them one at a time
  483.   switch(lpClient->iState)
  484.   { // Command mode?
  485.    case STATE_WAIT_FOR_COMMAND:
  486.    {
  487.     int iLoop;
  488.  
  489.     //DEBUGIT("STATE_WAIT_FOR_COMMAND");
  490.     if(!(*szLine))
  491.     {
  492.      smtpSendMessage(lpClient, 500, MSG_UNKNOWN);
  493.      continue;  // CR, LF, or '\0' came across
  494.     }
  495.  
  496.     pLine=szLine;
  497.     while((*pLine!='\0')&&(*pLine!=' ')&&(*pLine!='\n'))
  498.             pLine++;
  499.     AnsiLower((LPSTR)szLine);
  500.     if(*pLine!='\0')
  501.     {
  502.      *(pLine++)='\0';
  503.     }
  504.         // szLine now holds the lowercase command
  505.         // pLine points to the remaining parameters
  506.     iLoop=0;
  507.     bCmdOk=FALSE;
  508.     while(smtpCodesTable[iLoop].SMTPCommand != NULL)
  509.     {
  510.      if(lstrcmp((LPSTR)smtpCodesTable[iLoop].SMTPCommand,
  511.                 (LPSTR)szLine)==0)
  512.      {
  513.       smtpParser(lpClient, smtpCodesTable[iLoop].SMTPCode, pLine);
  514.       bCmdOk=TRUE;
  515.       break;
  516.      }
  517.      iLoop++;
  518.     }
  519.     if(!bCmdOk) smtpSendMessage(lpClient, 500, MSG_UNKNOWN);
  520.    }
  521.    break;
  522.  
  523.     // Data mode?
  524.    case STATE_WAIT_FOR_DOT:
  525.    {
  526.     //DEBUGIT("STATE_WAIT_FOR_DOT");
  527.     if((szLine[0]=='.')&&(szLine[1]=='\0'))
  528.     {
  529.      lpClient->iState=STATE_WAIT_FOR_COMMAND;
  530.      if(lpClient->hfFile!=HFILE_ERROR)
  531.      {
  532.              _lclose(lpClient->hfFile);
  533.      }
  534.      lpClient->hfFile=HFILE_ERROR;
  535.         // Handle MAIL/SAML/SOML as MAIL
  536.      if((lpClient->iMessageType==CMDMAIL)||
  537.         (lpClient->iMessageType==CMDSAML)||
  538.         (lpClient->iMessageType==CMDSOML))
  539.      {
  540.       smtpAppendToFile(lpClient, szLocalMailPath,
  541.                        lpClient->szFile);
  542.      }
  543.         // Handle SAML/SEND as SEND also
  544.      if((lpClient->iMessageType==CMDSAML)||
  545.         (lpClient->iMessageType==CMDSEND))
  546.      {
  547.       smtpDisplayFile(lpClient, lpClient->szFile);
  548.      }
  549.      smtpSendMessage(lpClient, 250, MSG_OK);
  550.      continue;
  551.     }
  552.     else if((szLine[0]=='.')&&(szLine[1]=='.'))
  553.     {   // Byte stuff it! Someone tried to send a '.' in their
  554.         // message. Only the first '.' is doubled.
  555.      lstrcpy((LPSTR)szPaddedLine, (LPSTR)(szLine+1));
  556.      lstrcpy((LPSTR)szLine, (LPSTR)szPaddedLine);
  557.     }
  558.         // All non '.' lines are stored.
  559.     if(lpClient->hfFile!=HFILE_ERROR)
  560.     {
  561.      wsprintf((LPSTR)szPaddedLine, "%s\r\n", (LPSTR)szLine);
  562.      iDebug=_lwrite(lpClient->hfFile,
  563.              (LPSTR)szPaddedLine, lstrlen((LPSTR)szPaddedLine));
  564.     }
  565.     continue;
  566.    } /* case(data mode)  */
  567.    break;
  568.   } /* switch(mode);     */
  569.   if(bConnectionQuit) break;
  570.  } /* while(lines exist);*/
  571.  //DEBUGIT("smtpServer() End");
  572.  return(FALSE);
  573. } /* smtpServer() */
  574.  
  575.  
  576. /* BOOL smtpParser(LPSMTPCLIENT, int, LPSTR);
  577.     Purpose: The actual parser of the SMTP "language"
  578.     Given:   Client pointer, Token of command, and it's arguments
  579. */
  580. BOOL smtpParser(LPSMTPCLIENT lpClient, int iToken, LPSTR lpArgs)
  581. {
  582.  //DEBUGIT("smtpParser() Begin");
  583.  switch(iToken)
  584.  {
  585.     // HELO - SMTP client is identifying itself
  586.   case CMDHELO:
  587.   {
  588.    //DEBUGIT("CMDHELO Begin");
  589.    if(lstrcmpi(lpClient->szPeer, lpArgs) != 0)
  590.    {
  591.     if(lstrlen(lpArgs) == 0)
  592.         smtpSendMessage(lpClient, 250, MSG_WHOAREYOU_S_S,
  593.                     (LPSTR)szLocalHostName,
  594.                     lpClient->szPeer);
  595.     else
  596.         smtpSendMessage(lpClient, 250, MSG_WHOAREYOU_S_S_S,
  597.                     (LPSTR)szLocalHostName,
  598.                     lpClient->szPeer,
  599.                     lpArgs);
  600.    }
  601.    else
  602.    {
  603.     smtpSendMessage(lpClient, 250, MSG_HELLO_S_S,
  604.                     (LPSTR)szLocalHostName,
  605.                     lpArgs);
  606.    }
  607.    //DEBUGIT("CMDHELO End");
  608.    return(FALSE);
  609.   }
  610.  
  611.     // EHLO - ESMTP client is identifying itself
  612.   case CMDEHLO:
  613.   {
  614.    //DEBUGIT("CMDEHLO Begin");
  615.    if(lstrcmpi(lpClient->szPeer,
  616.                lpArgs) != 0)
  617.    {
  618.     if(lstrlen(lpArgs) == 0)
  619.         smtpSendMessage(lpClient, 250, MSG_HWOAREYOU_S_S,
  620.                     (LPSTR)szLocalHostName,
  621.                     lpClient->szPeer);
  622.     else
  623.         smtpSendMessage(lpClient, 250, MSG_HWOAREYOU_S_S_S,
  624.                     (LPSTR)szLocalHostName,
  625.                     lpClient->szPeer,
  626.                     lpArgs);
  627.    }
  628.    else
  629.    {
  630.     smtpSendMessage(lpClient, 250, MSG_EHLLO_S_S,
  631.                     (LPSTR)szLocalHostName,
  632.                     lpArgs);
  633.    }
  634.    lpClient->iExtendedFlags |= ESMTP_EHLO_USED;
  635.    //DEBUGIT("CMDEHLO End");
  636.    return(FALSE);
  637.   }
  638.  
  639.     // Oh, joy.
  640.   case CMDSEND: // Send user a message to screen
  641.   case CMDSAML: // Send to screen AND store as mail
  642.   case CMDSOML: // Send to screen OR store as mail
  643.   case CMDMAIL: // Store as mail to user
  644.   {
  645.    LPSTR lpPtr;
  646.    LPSTR lpWalk;
  647.    LPSTR lpMark;
  648.    BOOL bSentReply = FALSE;
  649.  
  650.    //DEBUGIT("CMDMAIL Begin");
  651.    lpClient->iMessageType=iToken;
  652.    if(lpClient->bHaveFrom)
  653.    {
  654.     smtpSendMessage(lpClient, 503, MSG_ALREADYSENDER);
  655.     return(FALSE);
  656.    }
  657.    else
  658.    {
  659.     if(*lpArgs=='\0') break;
  660.     if( ( lpPtr = smtpSkipWord( lpClient, lpArgs, (LPSTR)"from" )) != NULL )
  661.     {
  662.      lpClient->bHaveFrom=TRUE;
  663.         // No long name crashes!
  664.      if(lstrlen(lpPtr)>=sizeof(lpClient->szFrom))
  665.             lpPtr[sizeof(lpClient->szFrom)-1] = '\0';
  666.  
  667.         // 8BITMIME and other ESMTP hacks
  668.      if(lpClient->iExtendedFlags & ESMTP_EHLO_USED)
  669.      {
  670.         // Check for ESMTP commands after the Sender's address
  671.       lpWalk=lpPtr;
  672.       while((*lpWalk!='>') && *lpWalk ) lpWalk++;
  673.       if((*lpWalk)&&(*(lpWalk+1)))
  674.       {
  675.        if(*(++lpWalk)==' ')
  676.        {
  677.         while(*lpWalk==' ') *lpWalk++ = '\0';
  678.         lpMark=lpWalk;
  679.         while((*lpWalk!='=') && *lpWalk ) lpWalk++;
  680.         if(*lpWalk) *lpWalk++ = '\0';
  681.         if(lstrcmpi(lpMark, "BODY") == 0)
  682.         {
  683.          lpMark=lpWalk;
  684.          while((*lpWalk!=' ') && *lpWalk ) lpWalk++;
  685.          if(*lpWalk) *lpWalk++ = '\0';
  686.          if(lstrcmpi(lpMark, "8BITMIME") == 0)
  687.          {
  688.           lpClient->iExtendedFlags |= ESMTP_8BITMIME;
  689.           bSentReply=TRUE;
  690.           smtpSendMessage(lpClient, 250, MSG_SENDEROK_8BITMIME_S,
  691.                           (LPSTR)lpPtr);
  692.          } // if 8BITMIME found
  693.         } // if BODY= found
  694.        } // if address is followed by a space
  695.       } // if something was found after the address
  696.      } // if extended commands are in effect
  697.  
  698.      lstrcpy(lpClient->szFrom,
  699.              lpPtr);
  700.      if(!bSentReply) smtpSendMessage(lpClient, 250, MSG_SENDEROK_S,
  701.                                      lpPtr);
  702.      //DEBUGIT("CMDMAIL End (Extended)");
  703.      return(FALSE);
  704.     }
  705.         // a 501 error was already sent
  706.     //DEBUGIT("CMDMAIL End (Already Sender)");
  707.     return(FALSE);
  708.    }
  709.    //DEBUGIT("CMDHELO End (Normal)");
  710.   } break;
  711.  
  712.     // RCPT - Client is identifying recipient's ID
  713.   case CMDRCPT:
  714.   {
  715.    LPSTR lpPtr;
  716.  
  717.    //DEBUGIT("CMDRCPT Begin");
  718.    if( *lpArgs == '\0' ) break;
  719.    if( ( lpPtr = smtpSkipWord( lpClient, lpArgs, (LPSTR)"to" )) != NULL )
  720.    {
  721.         // No long name crashes!
  722.     if(lstrlen(lpPtr)>=sizeof(lpClient->szTo))
  723.             lpPtr[sizeof(lpClient->szTo)-1] = '\0';
  724.     lstrcpy(lpClient->szTo,
  725.             lpPtr);
  726.     smtpSendMessage( lpClient, 250, MSG_RECIPIENTOK_S,
  727.                      lpPtr );
  728.     //DEBUGIT("CMDRCPT End (Recipient ok)");
  729.     return(FALSE);
  730.    }
  731.        // A 501 error was already sent
  732.    //DEBUGIT("CMDRCPT End (???)");
  733.    return(FALSE);
  734.   } break;
  735.  
  736.     // DATA - Client is sending actual mail message
  737.   case CMDDATA:
  738.   {
  739.    HFILE hfFile;
  740.    char szFile[MAXFILENAME];
  741.    OFSTRUCT ofOpenFileStruct;
  742.  
  743.    //DEBUGIT("CMDDATA Begin");
  744.    if(!lpClient->bHaveFrom)
  745.    {
  746.     smtpSendMessage(lpClient, 503, MSG_NEEDMAIL);
  747.     //DEBUGIT("CMDDATA End (Need mail?)");
  748.     return(FALSE);
  749.    }
  750.         // Open a temporary file
  751.    GetTempFileName(0, (LPSTR)STRING_PREFIX, 0, (LPSTR)szFile);
  752.    hfFile=OpenFile((LPSTR)szFile, (OFSTRUCT FAR *)&ofOpenFileStruct,
  753.                     OF_CREATE | OF_WRITE | OF_SHARE_EXCLUSIVE);
  754.  
  755.    if(hfFile==HFILE_ERROR)
  756.    {
  757.     smtpSendMessage(lpClient, 503, MSG_NOTEMP);
  758.     //DEBUGIT("CMDDATA End (No temporary file)");
  759.     return(FALSE);
  760.    }
  761.         // Ok, everything is ready to start the message.
  762.    lpClient->iState=STATE_WAIT_FOR_DOT;
  763.    lpClient->hfFile=hfFile;
  764.    lstrcpy(lpClient->szFile,
  765.            (LPSTR)szFile);
  766.  
  767.    smtpMakeHeader(lpClient, hfFile, lpClient->szPeer,
  768.                   lpClient->szFrom,
  769.                   lpClient->szTo);
  770.  
  771.    if(lpClient->iExtendedFlags & ESMTP_8BITMIME)
  772.      smtpSendMessage(lpClient, 354, MSG_SEND8BITMIME);
  773.    else
  774.      smtpSendMessage(lpClient, 354, MSG_SENDDATA);
  775.  
  776.    //DEBUGIT("CMDDATA End");
  777.    return(FALSE);
  778.   }
  779.  
  780.   case CMDRSET:
  781.   {
  782.    //DEBUGIT("CMDRSET Begin");
  783.    lpClient->iState=STATE_WAIT_FOR_COMMAND;
  784.    lpClient->iExtendedFlags=ESMTP_NONE;
  785.    lpClient->bHaveFrom=FALSE;
  786.    lpClient->szFrom[0]='\0';
  787.    lpClient->szTo[0]='\0';
  788.    smtpSendMessage(lpClient, 250, MSG_RESET);
  789.    //DEBUGIT("CMDRSET End");
  790.    return(FALSE);
  791.   }
  792.  
  793.   case CMDVRFY:
  794.   {
  795.    //DEBUGIT("CMDVRFY Begin");
  796.    smtpSendMessage(lpClient, 250, MSG_IDONTDOTHATYET);
  797.    //DEBUGIT("CMDVRFY Begin");
  798.    return(FALSE);
  799.   }
  800.  
  801.   case CMDHELP:
  802.   {
  803.    //DEBUGIT("CMDHELP Begin");
  804.    if(*lpArgs=='\0')
  805.    {
  806.     smtpSendHelp(lpClient, NULL);
  807.    }
  808.    else smtpSendHelp(lpClient, lpArgs);
  809.    //DEBUGIT("CMDHELP End");
  810.    return(FALSE);
  811.   } break;
  812.  
  813.   case CMDNOOP:
  814.   {
  815.    //DEBUGIT("CMDNOOP Begin");
  816.    smtpSendMessage(lpClient, 200, MSG_OK);
  817.    //DEBUGIT("CMDNOOP Begin");
  818.    return(FALSE);
  819.   }
  820.  
  821.   case CMDQUIT:
  822.   {
  823.    //DEBUGIT("CMDQUIT Begin");
  824.    smtpSendMessage(lpClient, 221, MSG_GOODBYE_S,
  825.                    (LPSTR)szLocalHostName);
  826.    smtpDestroyClient(lpClient);
  827.    bConnectionQuit=TRUE;
  828.    //DEBUGIT("CMDQUIT End");
  829.    return(FALSE);
  830.   }
  831.  
  832.   case CMDVERB:
  833.   {
  834.    //DEBUGIT("CMDVERB Begin");
  835.    smtpSendMessage(lpClient, 200, MSG_VERBOSEMODE);
  836.    //DEBUGIT("CMDVERB End");
  837.    return(FALSE);
  838.   }
  839.  
  840.   case CMDONEX:
  841.   {
  842.    //DEBUGIT("CMDONEX Begin");
  843.    smtpSendMessage(lpClient, 200, MSG_ONETRANSACTION);
  844.    //DEBUGIT("CMDONEX End");
  845.    return(FALSE);
  846.   }
  847.  
  848.   case CMDTICK:
  849.   {
  850.    //DEBUGIT("CMDTICK Begin");
  851.    smtpSendMessage(lpClient, 250, MSG_OK);
  852.    //DEBUGIT("CMDTICK End");
  853.    return(FALSE);
  854.   }
  855.  
  856.   case CMDXWIN3:
  857.   {
  858.    //DEBUGIT("CMDXWIN3 Begin");
  859.    smtpSendMessage(lpClient, 250, MSG_WIN3OK);
  860.    //DEBUGIT("CMDXWIN3 End");
  861.    return(FALSE);
  862.   }
  863.  
  864.   case CMDDBGQSHOW:
  865.   {
  866.    //DEBUGIT("CMDDBGQSHOW Begin");
  867.    smtpSendMessage(lpClient, 200, MSG_SHOWQ);
  868.    //DEBUGIT("CMDDBGQSHOW End");
  869.    return(FALSE);
  870.   }
  871.  
  872.   case CMDDBGDEBUG:
  873.   {
  874.    //DEBUGIT("CMDDBGDEBUG Begin");
  875.    smtpSendMessage(lpClient, 200, MSG_DEBUGSET);
  876.    //DEBUGIT("CMDDBGDEBUG End");
  877.    return(FALSE);
  878.   }
  879.  
  880.   case CMDMULT:
  881.   {
  882.    //DEBUGIT("CMDMULT Begin");
  883.    smtpSendMessage(lpClient, 250, MSG_OK);
  884.    //DEBUGIT("CMDMULT End");
  885.    return(FALSE);
  886.   }
  887.  
  888.   case CMDERROR:
  889.     //DEBUGIT("CMDERROR");
  890.   default:
  891.   break;
  892.  }
  893.  smtpSendMessage(lpClient, 500, MSG_UNKNOWN);
  894.  //DEBUGIT("smtpParser() End");
  895.  return(FALSE);
  896. } /* smtpParser() */
  897.  
  898.  
  899. /* void smtpMakeHeader(LPSMTPCLIENT, HFILE, LPSTR, LPSTR, LPSTR);
  900.     Purpose: To create the "header" portion of the mail
  901.              file.
  902.     Given:   Client pointer, Open (and valid) file handle,
  903.              Peer name, From and To strings.
  904.     Returns: Nothing.
  905. */
  906. void smtpMakeHeader(LPSMTPCLIENT lpClient, HFILE hfFile, LPSTR lpPeer,
  907.                     LPSTR lpFrom, LPSTR lpTo)
  908. {
  909.  int iSize;
  910.  char szTime[30];
  911.  char szBuffer[MAXLINE];
  912.  LPSOCKADDR_IN lpsaHostAddr;
  913.  
  914.  //DEBUGIT("smtpMakeHeader() Begin");
  915.  lpsaHostAddr=(LPSOCKADDR_IN)&(lpClient->saPeer);
  916.  
  917.  netGetTimeAndDate((LPSTR)szTime, sizeof(szTime));
  918.  
  919.  iSize=wsprintf((LPSTR)szBuffer, "\r\nFrom %s %s\r\n",
  920.                 lpFrom, (LPSTR)szTime);
  921.  _lwrite(hfFile, (LPSTR)szBuffer, iSize);
  922.  
  923.  iSize=wsprintf((LPSTR)szBuffer, "X-Envelope-To: %s\r\n",
  924.                 lpTo);
  925.  _lwrite(hfFile, szBuffer, iSize);
  926.  
  927.  iSize=wsprintf((LPSTR)szBuffer, "Return-Path: %s\r\n",
  928.                 lpFrom);
  929.  _lwrite(hfFile, (LPSTR)szBuffer, iSize);
  930.  
  931.  if(lpClient->iExtendedFlags & ESMTP_8BITMIME)
  932.  {
  933.   iSize=wsprintf((LPSTR)szBuffer,
  934.        "Received: from %s [%s] by %s (1.0/WINSMTPSRV/8BITMIME)\r\n",
  935.                 lpPeer,
  936.                 inet_ntoa(lpsaHostAddr->sin_addr),
  937. /*  inet_ntoa() and [%s] or this and [%d.%d.%d.%d], take your pick
  938.                 lpsaHostAddr->sin_addr.S_un.S_un_b.s_b1,
  939.                 lpsaHostAddr->sin_addr.S_un.S_un_b.s_b2,
  940.                 lpsaHostAddr->sin_addr.S_un.S_un_b.s_b3,
  941.                 lpsaHostAddr->sin_addr.S_un.S_un_b.s_b4,
  942. */
  943.                 (LPSTR)szLocalHostName);
  944.  }
  945.  else
  946.  {
  947.   iSize=wsprintf((LPSTR)szBuffer,
  948.        "Received: from %s [%s] by %s (1.61/WINSMTPSRV)\r\n",
  949.                 lpPeer,
  950.                 inet_ntoa(lpsaHostAddr->sin_addr),
  951.                 (LPSTR)szLocalHostName);
  952.  }
  953.  
  954.  _lwrite(hfFile, (LPSTR)szBuffer, iSize);
  955.  
  956.      // Log incoming to/from
  957.  wsprintf((LPSTR)szBuffer, "Message from: %s  to: %s",
  958.           lpFrom, lpTo);
  959.  SendDlgItemMessage(hWndDlg, IDL_LOG, LB_ADDSTRING, 0,
  960.                      (LPARAM)(LPCSTR)szBuffer);
  961.  //DEBUGIT("smtpMakeHeader() End");
  962.  return;
  963. } /* smtpMakeHeader */
  964.  
  965.  
  966. /* void smtpSendHelp(LPSMTPCLIENT, LPSTR);
  967.     Purpose: To give the remote user help (not batch, obviously)
  968.     Given:   Client Index, Topic
  969.     Returns: Nothing.
  970. */
  971. void smtpSendHelp(LPSMTPCLIENT lpClient,LPSTR lpTopic)
  972. {
  973.  LPSTR lpLine;
  974.  int  iLoop;
  975.  WORD wTopic;
  976.  char szBuffer[MAXSNDBUFF];
  977.  
  978.  //DEBUGIT("smtpSendHelp() Begin");
  979.  if(lpTopic!=NULL)
  980.  {
  981.   lpLine=lpTopic;
  982.  
  983.   // pLine points to the HELP parameters
  984.   iLoop=0;
  985.   wTopic=CMDHELP;
  986.   while(smtpCodesTable[iLoop].SMTPCommand != NULL)
  987.   {
  988.    if(lstrcmp((LPSTR)smtpCodesTable[iLoop].SMTPCommand,
  989.               lpLine)==0)
  990.    {
  991.     wTopic=(WORD)smtpCodesTable[iLoop].SMTPCode;
  992.     break;
  993.    }
  994.    iLoop++;
  995.   }
  996.  }
  997.  else wTopic=CMDHELP;
  998.  
  999.  smtpSendMessage(lpClient, 214, wTopic);
  1000.  
  1001.     // Kludge
  1002.  if(lpTopic==NULL)
  1003.  {
  1004.   lstrcpy((LPSTR)szBuffer, "HELP");
  1005.  }
  1006.  else
  1007.  {
  1008.   lstrcpy((LPSTR)szBuffer, (LPSTR)smtpCodesTable[iLoop].SMTPCommand);
  1009.   AnsiUpper((LPSTR)szBuffer);
  1010.  }
  1011.  
  1012.  smtpSendMessage(lpClient, 214, MSG_END_HELP_S, (LPSTR)szBuffer);
  1013.  //DEBUGIT("smtpSendHelp() End");
  1014.  return;
  1015. } /* smtpSendHelp */
  1016.  
  1017.  
  1018. /* LPSTR smtpSkipWord(LPSMTPCLIENT, LPSTR, LPSTR);
  1019.     Purpose: To skip over words not neccisary on an SMTP line.
  1020.     Given:   Client pointer, string to examine, word to skip
  1021.     Returns: NULL if error, rest of line if not
  1022. */
  1023. LPSTR smtpSkipWord(LPSMTPCLIENT lpClient, LPSTR lpString, LPSTR lpWord)
  1024. {
  1025.  LPSTR lpTemp;
  1026.  
  1027.  //DEBUGIT("smtpSkipWord() Begin");
  1028.  while((*lpString==' ')||(*lpString=='\t'))  lpString++;
  1029.  lpTemp=lpString;
  1030.  while((*lpString!='\0')&&(*lpString!=':')&&
  1031.        !((*lpString==' ')||(*lpString=='\t'))) lpString++;
  1032.  while((*lpString==' ')||(*lpString=='\t')) *(lpString++)=='\0';
  1033.  if(*lpString!=':')
  1034.  {
  1035.   smtpSendMessage(lpClient, 501, MSG_SYNTAXERROR);
  1036.   return(NULL);
  1037.  }
  1038.  *(lpString++)='\0';
  1039.  while((*lpString==' ')||(*lpString=='\t')) lpString++;
  1040.  if(lstrcmpi(lpTemp, lpWord))
  1041.  {
  1042.   smtpSendMessage(lpClient, 501, MSG_SYNTAXERROR);
  1043.   return(NULL);
  1044.  }
  1045.  //DEBUGIT("smtpSkipWord() End");
  1046.  return(lpString);
  1047. } /* smtpSkipWord */
  1048.  
  1049.  
  1050. /* void smtpAppendToFile(LPSMTPCLIENT, LPSTR, LPSTR);
  1051.     Purpose: To copy one file to the end of another.
  1052.     Given:   Pointer to a SMTPCLIENT for error messages,
  1053.              Filename of the file to append to,
  1054.              Filename of the file to append from.
  1055.     Returns: Nothing.
  1056. */
  1057. void smtpAppendToFile(LPSMTPCLIENT lpClient, LPSTR lpTo, LPSTR lpFrom)
  1058. {
  1059.  HFILE hTo, hFrom;
  1060.  char szBuffer[MAXSNDBUFF];
  1061.  int iSize;
  1062.  OFSTRUCT ofToFileStruct,
  1063.           ofFromFileStruct;
  1064.  
  1065.  //DEBUGIT("smtpAppendToFile() Begin");
  1066.     // Open the MAIL file for reading
  1067.  hTo=OpenFile(lpTo, (OFSTRUCT FAR *)&ofToFileStruct,
  1068.               OF_WRITE | OF_SHARE_EXCLUSIVE);
  1069.     // Does the main MAIL file exist?
  1070.  if(hTo==HFILE_ERROR)
  1071.  {
  1072.     // No? Create one.
  1073.   hTo=OpenFile(lpTo, (OFSTRUCT FAR *)&ofToFileStruct,
  1074.                OF_CREATE | OF_WRITE | OF_SHARE_EXCLUSIVE);
  1075.     // Serious error!
  1076.   if(hTo==HFILE_ERROR)
  1077.   {
  1078.    smtpSendMessage(lpClient, 503, MSG_MAILOPEN);
  1079.    smtpError(IDS_COULDNTOPEN_S, lpTo);
  1080.    //DEBUGIT("smtpAppendToFile() End (File error 1)");
  1081.    return;
  1082.   }
  1083.  }
  1084.  
  1085.     // Open the temporary file
  1086.  hFrom=OpenFile(lpFrom, (OFSTRUCT FAR *)&ofToFileStruct,
  1087.                 OF_READ | OF_SHARE_DENY_WRITE);
  1088.  if(hFrom==HFILE_ERROR)
  1089.  {
  1090.    smtpSendMessage(lpClient, 503, MSG_TEMPOPEN);
  1091.    smtpError(IDS_COULDNTOPEN_S, lpFrom);
  1092.    _lclose(hTo);
  1093.    //DEBUGIT("smtpAppendToFile() End (File error 2)");
  1094.    return;
  1095.  }
  1096.  
  1097.     // Seek to the end of the main MAIL file
  1098.  if(_llseek(hTo, 0, 2)==HFILE_ERROR)
  1099.  {
  1100.   smtpSendMessage(lpClient, 503, MSG_SEEKERROR);
  1101.   smtpError(IDS_FILEERROR_S, lpTo);
  1102.   _lclose(hTo);
  1103.   _lclose(hFrom);
  1104.    //DEBUGIT("smtpAppendToFile() End (File error 3)");
  1105.   return;
  1106.  }
  1107.  
  1108.     // Copy the temporary file to the end of the MAIL file
  1109.  while(iSize=_lread(hFrom, (LPSTR)szBuffer, sizeof(szBuffer)))
  1110.  {
  1111.   if((iSize==HFILE_ERROR)||
  1112.      (_lwrite(hTo, (LPSTR)szBuffer, iSize)==HFILE_ERROR)) break;
  1113.  }
  1114.     // Close 'em both
  1115.  _lclose(hTo);
  1116.  _lclose(hFrom);
  1117.  
  1118.     // Icon Flag!
  1119.  bMailArrived=TRUE;
  1120.  SetProp(hWndDlg, "icon", LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICONFULL)));
  1121.  RedrawWindow(hWndDlg, NULL, NULL, RDW_INTERNALPAINT);
  1122.  
  1123.     // Tell user mail just came
  1124.  MessageBeep(MB_ICONEXCLAMATION);
  1125.  
  1126.     // Wait a bit and check to see if this mail still exists
  1127.  SetTimer(hWndDlg, (UINT)ID_TIMER, (UINT)TIME_CHECK, NULL);
  1128.  
  1129.     // Delete the temporary file
  1130.  if(!lpClient) return;
  1131.  if(lpClient->iMessageType!=CMDSAML)
  1132.  {
  1133.   OpenFile(lpFrom, (OFSTRUCT FAR *)&ofFromFileStruct,
  1134.            OF_DELETE);
  1135.  }
  1136.  //DEBUGIT("smtpAppendToFile() End");
  1137.  return;
  1138. } /* smtpAppendToFile() */
  1139.  
  1140.  
  1141. /* BOOL smtpMailCheck(LPSTR);
  1142.     Purpose: To check to see if the main mail file still exists.
  1143.     Given:   Filename of the main file to check for.
  1144.     Returns: Nothing.
  1145.     Other:   Modifies mail flag
  1146. */
  1147. BOOL smtpMailCheck(LPSTR lpFilename)
  1148. {
  1149.  OFSTRUCT ofFile;
  1150.  HICON hIcon;
  1151.  
  1152.  if(OpenFile(lpFilename, (OFSTRUCT FAR *)&ofFile,
  1153.              OF_EXIST | OF_SHARE_COMPAT) != HFILE_ERROR)
  1154.  {
  1155.   if(!bMailArrived)
  1156.   {
  1157.    bMailArrived=TRUE;
  1158.  
  1159.    hIcon=LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICONFULL));
  1160.    SetProp(hWndDlg, "icon", hIcon);
  1161.    RedrawWindow(hWndDlg, NULL, NULL, RDW_INTERNALPAINT);
  1162.   }
  1163.  }
  1164.  else
  1165.  {
  1166.   if(bMailArrived)
  1167.   {
  1168.    bMailArrived=FALSE;
  1169.    hIcon=LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICONEMPTY));
  1170.    SetProp(hWndDlg, "icon", hIcon);
  1171.    RedrawWindow(hWndDlg, NULL, NULL, RDW_INTERNALPAINT);
  1172.   }
  1173.  }
  1174.  return(bMailArrived);
  1175. } /* smtpMailCheck() */
  1176.  
  1177.  
  1178. /* BOOL smtpDisplayFile(LPSMTPCLIENT, LPSTR);
  1179.     Purpose: To display a mail message to the screen for
  1180.              SEND and SAML.
  1181.     Given:   Pointer to a related SMTPCLIENT struct, filename
  1182.     Return:  TRUE if error, FALSE if not.
  1183. */
  1184. BOOL smtpDisplayFile(LPSMTPCLIENT lpClient, LPSTR lpFilename)
  1185. {
  1186.  char szCommand[256];
  1187.  OFSTRUCT ofFile;
  1188.  
  1189.  //DEBUGIT("smtpDisplayFile() Begin");
  1190.     // Beep user to tell them mail came.
  1191.  MessageBeep(MB_ICONEXCLAMATION);
  1192.  
  1193.     // "Fork" off a notepad to handle it
  1194.  wsprintf((LPSTR)szCommand, "notepad %s", lpFilename);
  1195.  if(WinExec((LPSTR)szCommand, SW_SHOW)<32)
  1196.  {
  1197.   smtpAppendToFile(lpClient, (LPSTR)szLocalMailPath, lpFilename);
  1198.  }
  1199.  
  1200.     // Delete the temporary file
  1201.  if((lpClient->iMessageType==CMDSAML)||
  1202.     (lpClient->iMessageType==CMDSEND))
  1203.  {
  1204.   OpenFile(lpFilename, (OFSTRUCT FAR *)&ofFile,
  1205.            OF_DELETE);
  1206.  }
  1207.  //DEBUGIT("smtpDisplayFile() End");
  1208.  return(FALSE);
  1209. } /* smtpDisplayFile() */
  1210.  
  1211.  
  1212. /* LPSMTPCLIENT smtpAddClient(SOCKET);
  1213.     Purpose: Allocate a client structure and initilize it.
  1214.     Given:   SOCKET of a connection.
  1215.     Returns: A negative number on error, or a
  1216.              valid SMTPCLIENT index into
  1217.              smtpClientsTable
  1218.     Reusability notes:
  1219.              SMTPCLIENT smtpClientsTable;
  1220.              PHASE_INIT,3 MAXBUFF, MAXCLIENTS;
  1221. */
  1222. LPSMTPCLIENT smtpAddClient(SOCKET sSocket)
  1223. {
  1224.  int iRcvSize;
  1225.  int iSizeofRcvSize;
  1226.  HANDLE hInput, hOutput;
  1227.  HCLIENT hClient;
  1228.  LPSTR lpInput, lpOutput;
  1229.  LPSMTPCLIENT lpClient, lpWalker;
  1230.  
  1231.  //DEBUGIT("smtpAddClient() Begin");
  1232.     // Find the receiver buffer size
  1233.  iSizeofRcvSize=sizeof(iRcvSize);
  1234.  getsockopt(sSocket, SOL_SOCKET, SO_RCVBUF, (LPSTR)&iRcvSize,
  1235.             (LPINT)&iSizeofRcvSize );
  1236.  
  1237.     // Make sure we can handle a certain size line at a time
  1238.  if(iRcvSize<MAXSNDBUFF) iRcvSize=MAXSNDBUFF;
  1239.  
  1240.     // Make sure we can handle up to 2 buffers at a time
  1241.  iRcvSize=iRcvSize*2;
  1242.  
  1243.     // Allocate the receiver buffer
  1244.  hInput=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
  1245.                   iRcvSize);
  1246.  if(!hInput) return(NULL);
  1247.  lpInput=GlobalLock(hInput);
  1248.  if(!lpInput)
  1249.  {
  1250.   GlobalFree(hInput);
  1251.   return(NULL);
  1252.  }
  1253.  
  1254.     // Allocate the sending buffer
  1255.  // The size is permanent, we only need dynamic with incoming
  1256.  hOutput=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
  1257.                   MAXSNDBUFF);
  1258.  if(!hOutput)
  1259.  {
  1260.   GlobalUnlock(hInput);
  1261.   GlobalFree(hInput);
  1262.   return(NULL);
  1263.  }
  1264.  lpOutput=GlobalLock(hOutput);
  1265.  if(!lpOutput)
  1266.  {
  1267.   GlobalFree(hOutput);
  1268.   GlobalUnlock(hInput);
  1269.   GlobalFree(hInput);
  1270.   return(NULL);
  1271.  }
  1272.  
  1273.     // Allocate a SMTPCLIENT element
  1274.  hClient=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
  1275.                   sizeof(SMTPCLIENT));
  1276.  if(!hClient)
  1277.  {
  1278.   GlobalUnlock(hOutput);
  1279.   GlobalFree(hOutput);
  1280.   GlobalUnlock(hInput);
  1281.   GlobalFree(hInput);
  1282.   return(NULL);
  1283.  }
  1284.  lpClient=(LPSMTPCLIENT)GlobalLock(hClient);
  1285.  if(!lpClient)
  1286.  {
  1287.   GlobalFree(hClient);
  1288.   GlobalUnlock(hOutput);
  1289.   GlobalFree(hOutput);
  1290.   GlobalUnlock(hInput);
  1291.   GlobalFree(hInput);
  1292.   return(NULL);
  1293.  }
  1294.  
  1295.  lpClient->sSocket=sSocket;
  1296.  lpClient->bHaveFrom=FALSE;
  1297.  lpClient->hfFile=HFILE_ERROR;
  1298.  lpClient->hClient=hClient;
  1299.  
  1300.  lpClient->lpOutputBuffer=lpOutput;
  1301.  lpClient->hOutputBuffer=hOutput;
  1302.     // iOutputSize is MAXSNDBUFF
  1303.  lpClient->lpInputBuffer=lpInput;
  1304.  lpClient->hInputBuffer=hInput;
  1305.  lpClient->iInputSize=iRcvSize;
  1306.  
  1307.  lpClient->fifoOutputStart=0;
  1308.  lpClient->fifoOutputStop=0;
  1309.  lpClient->fifoInputStart=0;
  1310.  lpClient->fifoInputStop=0;
  1311.  lpClient->iState=STATE_WAIT_FOR_COMMAND;
  1312.  lpClient->iExtendedFlags=ESMTP_NONE;
  1313.  
  1314.  lpClient->lpNextClient=NULL;
  1315.  lpClient->lpPrevClient=NULL;
  1316.  
  1317.     // If this is the main listening socket, initialize List
  1318.  if(!smtpClientsHead)
  1319.  {
  1320.   smtpClientsHead=lpClient;
  1321.  }
  1322.  else
  1323.  {
  1324.   lpWalker=smtpClientsHead;
  1325.   while(lpWalker->lpNextClient) lpWalker=lpWalker->lpNextClient;
  1326.   lpWalker->lpNextClient=lpClient;  // Add new tail segment
  1327.   lpClient->lpPrevClient=lpWalker;  // Tell tail who's its parent
  1328.  }
  1329.  
  1330.  //DEBUGIT("smtpAddClient() End");
  1331.  return(lpClient);
  1332. } /* smtpAddClient */
  1333.  
  1334.  
  1335. /* LPSMTPCLIENT smtpSocketToClient(SOCKET sSocket) */
  1336. LPSMTPCLIENT smtpSocketToClient(SOCKET sSocket)
  1337. {
  1338.  LPSMTPCLIENT lpClient;
  1339.  
  1340.  if((!lpClient)||(sSocket==SOCKET_ERROR)) return(NULL);
  1341.  lpClient=smtpClientsHead;
  1342.  
  1343.  while(lpClient!=NULL)
  1344.  {
  1345.   if(lpClient->sSocket==sSocket) return(lpClient);
  1346.   lpClient=lpClient->lpNextClient;
  1347.  }
  1348.  return(lpClient);
  1349. } /* smtpSocketToClient() */
  1350.  
  1351.  
  1352. /* BOOL smtpDestroyClient(LPSMTPCLIENT);
  1353.     Purpose: To release a SMTPCLIENT structure.
  1354.     Given:   Linked list element pointer
  1355.     Returns: TRUE if error, FALSE if all OK
  1356.     Reusability notes:
  1357. */
  1358. BOOL smtpDestroyClient(LPSMTPCLIENT lpClient)
  1359. {
  1360.  BOOL bLinger = FALSE;
  1361.  LPSMTPCLIENT lpNext, lpPrev;
  1362.  
  1363.  //DEBUGIT("smtpDestroyClient() Begin");
  1364.  if(!lpClient) return(TRUE);
  1365.  
  1366.     // This code was removed as "dead" code. The setsockopt() just sets
  1367.     // the SO_LINGER option to what it already should be by default
  1368.     // (thanks Bob (rcq@ftp.com))
  1369. // setsockopt(lpClient->sSocket,
  1370. //            SOL_SOCKET, SO_LINGER, (char FAR *)&bLinger,
  1371. //            sizeof(BOOL));
  1372.     // This shutdown isn't needed either...
  1373. // shutdown(lpClient->sSocket, 2);
  1374.  closesocket(lpClient->sSocket);
  1375.  
  1376.  smtpLog(LOG_HIGH | LOG_TIME, LOG_DISCONNECT_S, (LPSTR)lpClient->szPeer);
  1377.  
  1378.     // Hack Alert! This is a hack, this is only a hack. If this were
  1379.     // real winsock compliant code, it shouldn't have to do this!
  1380.     // But it doesn't hurt, and Lanera seems to need it?
  1381.     // Since this is non-standard, it is now no longer needed - but I
  1382.     // doubt if it will work on Lanera's stack anymore..
  1383.  //if(lpClient!=smtpClientsHead)
  1384.  //{
  1385.  // WSAAsyncSelect(smtpClientsHead->sSocket, hWndMain, NET_ACTIVITY,
  1386.  //                FD_ACCEPT | FD_READ | FD_WRITE | FD_CLOSE);
  1387.  //}
  1388.  
  1389.     // Is the DATA temporary file still open?
  1390.  if(lpClient->hfFile!=HFILE_ERROR)
  1391.  {
  1392.   _lclose(lpClient->hfFile);
  1393.     // Take it as valid - but don't send any messages
  1394.   smtpAppendToFile(NULL, szLocalMailPath,
  1395.                    lpClient->szFile);
  1396.  }
  1397.  
  1398.     // Patch out THIS segment.
  1399.  lpNext=lpClient->lpNextClient;
  1400.  lpPrev=lpClient->lpPrevClient;
  1401.  if(lpPrev) lpPrev->lpNextClient=lpNext;
  1402.  
  1403.     // Free all of the memory
  1404.  GlobalUnlock(lpClient->hInputBuffer);
  1405.  GlobalFree(lpClient->hInputBuffer);
  1406.  GlobalUnlock(lpClient->hOutputBuffer);
  1407.  GlobalFree(lpClient->hOutputBuffer);
  1408.  GlobalUnlock(lpClient->hClient);
  1409.  GlobalFree(lpClient->hClient);
  1410.  
  1411.  //DEBUGIT("smtpDestroyClient() End");
  1412.  return(FALSE);
  1413. } /* smtpDestroyClient */
  1414.  
  1415.  
  1416. /* void smtpSendMessage(LPSMTPCLIENT, int, int, ...);
  1417.     Purpose: To send a resource/reply message.
  1418.     Given:   index into smtpClientsTable
  1419.              SMTP reply number (211, 503)
  1420.              Resource ID of the reply string.
  1421.              ... arguments
  1422.     Returns: Nothing.
  1423.     Other:   If the Resource ID String has a '\n' in it,
  1424.              this routine will send it line at a time.
  1425. */
  1426. void smtpSendMessage(LPSMTPCLIENT lpClient, int SMTPCode, int ResourceID, ...)
  1427. {
  1428.  int iCount;
  1429.  char szString[MAXSNDBUFF];
  1430.  char szLine[MAXSNDBUFF];
  1431.  LPSTR lpArg1, lpArg2, lpArg3;
  1432.  PSTR pStart, pStop;
  1433.  va_list vaArgs;
  1434.  
  1435.  //DEBUGIT("smtpSendMessage() Begin");
  1436.  if(!lpClient) return;
  1437.  
  1438.  va_start( vaArgs, ResourceID);
  1439.  
  1440.  if(!LoadString(hInst, ResourceID, (LPSTR)szLine, sizeof(szLine)))
  1441.     return;
  1442.  
  1443.  lpArg1=va_arg(vaArgs, LPSTR);
  1444.  lpArg2=va_arg(vaArgs, LPSTR);
  1445.  lpArg3=va_arg(vaArgs, LPSTR);
  1446.  
  1447.  wsprintf((LPSTR)szString, (LPSTR)szLine, lpArg1, lpArg2, lpArg3);
  1448.  
  1449.  pStart=pStop=szString;
  1450.  do     /* Line loop for embedded '\n's */
  1451.  {
  1452.   while((*pStop!='\0')&&(*pStop!='\n')) pStop++;
  1453.   if((*pStop!='\0'))
  1454.   {
  1455.    *(pStop++)='\0';
  1456.    wsprintf((LPSTR)szLine, "%d-%s", SMTPCode, (LPSTR)pStart);
  1457.    pStart=pStop;
  1458.   }
  1459.   else
  1460.   {
  1461.    wsprintf((LPSTR)szLine, "%d %s", SMTPCode, (LPSTR)pStart);
  1462.   }
  1463.   clientSendLine(lpClient, (LPSTR)szLine, lstrlen((LPSTR)szLine));
  1464.   //DEBUGIT((LPSTR)szLine);
  1465.   smtpLog(LOG_HIGH, LOG_SENT_S, (LPCSTR)szLine);
  1466.  } while(*pStop!='\0');
  1467.  //DEBUGIT("smtpSendMessage() End");
  1468. } /* smtpSendMessage */
  1469.  
  1470.  
  1471. /* int clientSendLine(LPSMTPCLIENT, LPSTR, int);
  1472.     Purpose: Send 1 line to the caller if it exists.
  1473.     Given:   SMTPCLIENT index, Line pointer,
  1474.              Line size. (for binary "string" sends if needed)
  1475.     Returns: 0 if everything isn't ok.
  1476.              >0 tells the caller how many characters it sent.
  1477.     Reusability requirements:
  1478.              Globals: SMTPCLIENT smtpClientsTable[]
  1479.              Defines: MAXCLIENTS, MAXBUFF
  1480.     Other:   THIS ROUTINE ADDS A CR/LF PAIR!
  1481. */
  1482. int clientSendLine(LPSMTPCLIENT lpClient, LPSTR lpLine, int iLine)
  1483. {
  1484.  LPSTR lpBuffer;
  1485.  int fifoStart;
  1486.  int fifoStop;
  1487.  int fifoWalker;
  1488.  int iDest;
  1489.  
  1490.     /* Catch illegal arguements */
  1491.  if((!lpClient)||(lpLine==NULL)||(iLine==0))
  1492.      return(0);
  1493.  
  1494.     /* Make things easier to deal with */
  1495.  lpBuffer=lpClient->lpOutputBuffer;
  1496.  fifoStart=lpClient->fifoOutputStart;
  1497.  fifoWalker=fifoStart;
  1498.  fifoStop=lpClient->fifoOutputStop;
  1499.  
  1500.     /* Make sure there is enough room - Egad */
  1501.  if(( (fifoStop<fifoStart) &&
  1502.       (((fifoStop+iLine+2)&MAXSNDBUFF)>=fifoStart)
  1503.     )            ||
  1504.     ( (fifoStop>=fifoStart) &&
  1505.       (((fifoStop+iLine+2)/MAXSNDBUFF)==1) &&
  1506.       (((fifoStop+iLine+2)%MAXSNDBUFF)>=fifoStart)
  1507.     ))
  1508.     return(0);
  1509.  
  1510.     /* There is room at the end! Copy it in! */
  1511.  iDest=0;
  1512.  fifoWalker=fifoStop;
  1513.  while(iDest<iLine)
  1514.  {
  1515.   lpBuffer[fifoWalker]=lpLine[iDest];
  1516.   fifoWalker=(fifoWalker+1)%MAXSNDBUFF;
  1517.   iDest++;
  1518.  }
  1519.  lpBuffer[fifoWalker]='\r';      // Append CR on output
  1520.  fifoWalker=(fifoWalker+1)%MAXSNDBUFF;
  1521.  lpBuffer[fifoWalker]='\n';      // Append LF on output
  1522.  fifoWalker=(fifoWalker+1)%MAXSNDBUFF;
  1523.  
  1524.  lpClient->fifoOutputStop=fifoWalker;
  1525.     // This is important
  1526.  netSendData(lpClient);
  1527.  return(iDest);                  // Tell em how many we copied!
  1528. } /* clientSendLine */
  1529.  
  1530.  
  1531. /* int clientReceiveLine(LPSMTPCLIENT, LPSTR, int);
  1532.     Purpose: Receive 1 line for the caller if it exists.
  1533.     Given:   SMTPCLIENT pointer, Line buffer pointer,
  1534.              Line buffer size.
  1535.     Returns: -1 if no string found in buffer
  1536.              0 if just CR or NL
  1537.              >0 tells the caller how many characters it was.
  1538.     Reusability requirements:
  1539.              None!
  1540.     Notes:   This routines takes into account backspaces,
  1541.              deletes, multiple CRs and LFs.
  1542. */
  1543. int clientReceiveLine(LPSMTPCLIENT lpClient, LPSTR lpLine, int iLine)
  1544. {
  1545.  LPSTR lpBuffer;
  1546.  int iCount;
  1547.  int fifoStart;
  1548.  int fifoStop;
  1549.  int fifoWalker;
  1550.  int iDest;
  1551.  int iMax;
  1552.  
  1553.  if((!lpClient)||(lpLine==NULL)||(iLine==0))
  1554.      return(-1);
  1555.  
  1556.      /* Make things easier to deal with */
  1557.  lpBuffer=lpClient->lpInputBuffer;
  1558.  fifoStart=lpClient->fifoInputStart;
  1559.  fifoWalker=fifoStart;
  1560.  fifoStop=lpClient->fifoInputStop;
  1561.  iMax=lpClient->iInputSize;
  1562.  
  1563.  if(fifoStart==fifoStop) return(-1);
  1564.  
  1565.     /* Search buffer for a LF or CR BEFORE the end of the buffer! */
  1566.  while((lpBuffer[fifoWalker]!='\n')&&
  1567.        (lpBuffer[fifoWalker]!='\r'))
  1568.  {
  1569.   fifoWalker=(fifoWalker+1)%iMax;
  1570.   if(fifoWalker==fifoStop)
  1571.     return(-1);
  1572.  }
  1573.  
  1574.     /* We found the end of a string! Copy it out. */
  1575.  *lpLine='\0';
  1576.  
  1577.  iDest=0;
  1578.  fifoWalker=fifoStart;
  1579.  while((lpBuffer[fifoWalker]!='\n')&&
  1580.        (lpBuffer[fifoWalker]!='\r'))
  1581.  {
  1582.   if((lpBuffer[fifoWalker]=='\b')||     // Backspace (^H)
  1583.      (lpBuffer[fifoWalker]=='\177'))    // Delete    (^?)
  1584.   { // Interactive User is talking to us (and making mistakes)
  1585.    if((--iDest)<0) iDest=0;             // Backup if we can
  1586.    fifoWalker=(fifoWalker+1)%iMax;      // Step over ^H or ^?
  1587.    continue;                            // for ^H^H... case
  1588.   }
  1589.   lpLine[iDest]=lpBuffer[fifoWalker];
  1590.   fifoWalker=(fifoWalker+1)%iMax;
  1591.   iDest++;
  1592.   if(iDest>=iLine)
  1593.      return(-1);  // Not enough string space!!!
  1594.  }
  1595.  lpLine[iDest]='\0';
  1596.  
  1597.                                // Step past the '\r'
  1598.  if((fifoWalker!=fifoStop)&&
  1599.     (lpBuffer[fifoWalker]=='\r')) fifoWalker=(fifoWalker+1)%iMax;
  1600.  
  1601.                                // Step past the '\n'
  1602.  if((fifoWalker!=fifoStop)&&
  1603.     (lpBuffer[fifoWalker]=='\n')) fifoWalker=(fifoWalker+1)%iMax;
  1604.  
  1605.  lpClient->fifoInputStart=fifoWalker;
  1606.  smtpLog(LOG_HIGH, LOG_RECEIVED_S, (LPCSTR)lpLine);
  1607.  return(iDest);              // Tell em how many we copied!
  1608. } /* clientReceiveLine */
  1609.  
  1610.  
  1611. /* int clientReceiveBlock(int, LPSTR, int);
  1612.     Purpose: Receive entire FIFO block for the caller if it exists.
  1613.     Given:   SMTPCLIENT index, Block buffer pointer,
  1614.              Block buffer size.
  1615.     Returns: 0 if everything isn't ok. (no characters waiting)
  1616.              >0 tells the caller how many characters it was.
  1617.     Reusability requirements:
  1618.              Globals: SMTPCLIENT smtpClientsTable[]
  1619.              Defines: MAXCLIENTS, MAXBUFF
  1620.     Notes:   This kind of defeats the idea of FIFO, but it does
  1621.              allow for 8 bit binary transfers.
  1622.              Since it was easier to implement 8BITMIME termination
  1623.              in here, I have left it so. This is not good design.
  1624. */
  1625. int clientReceiveBlock(LPSMTPCLIENT lpClient, LPSTR lpLine, int iLine)
  1626. {
  1627.  LPSTR lpBuffer;
  1628.  int fifoStart;
  1629.  int fifoStop;
  1630.  int fifoWalker;
  1631.  int iDest;
  1632.  int iMax;
  1633.  
  1634.  if((!lpClient)||(lpLine==NULL)||(iLine==0))
  1635.      return(0);
  1636.  
  1637.     // Make things easier to deal with
  1638.  lpBuffer=lpClient->lpInputBuffer;
  1639.  fifoStart=lpClient->fifoInputStart;
  1640.  fifoStop=lpClient->fifoInputStop;
  1641.  iMax=lpClient->iInputSize;
  1642.  
  1643.  if(fifoStart==fifoStop) return(0);
  1644.  
  1645.  iDest=0;
  1646.  fifoWalker=fifoStart;
  1647.  while(fifoWalker!=fifoStop)
  1648.  {
  1649.   if(lpBuffer[fifoWalker]=='.')
  1650.   {
  1651.     // Check for presence of, and validity of "\r\n.\r\n"
  1652.     // Elegant, yet ugly
  1653.     // Possible bug: What if the above sequence comes split?
  1654.    if(((((fifoWalker-2)%iMax) != fifoStart) &&
  1655.        (lpBuffer[(fifoWalker-2)%iMax]=='\r'))
  1656.     &&((((fifoWalker-1)%iMax) != fifoStart) &&
  1657.        (lpBuffer[(fifoWalker-1)%iMax]=='\n'))
  1658.     &&((((fifoWalker+1)%iMax) != fifoStop) &&
  1659.        (lpBuffer[(fifoWalker+1)%iMax]=='\r'))
  1660.     &&((((fifoWalker+2)%iMax) != fifoStop) &&
  1661.        (lpBuffer[(fifoWalker+2)%iMax]=='\n'))
  1662.      )
  1663.    {    // End of message
  1664.      if(lpClient->hfFile!=HFILE_ERROR)
  1665.      {
  1666.              _lclose(lpClient->hfFile);
  1667.      }
  1668.      lpClient->hfFile=HFILE_ERROR;
  1669.      smtpAppendToFile(lpClient, szLocalMailPath,
  1670.                       lpClient->szFile);
  1671.      lpClient->iState=STATE_WAIT_FOR_COMMAND;
  1672.      smtpSendMessage(lpClient, 250, MSG_OK);
  1673.      fifoWalker=(fifoWalker+2)%iMax;
  1674.      break;
  1675.    }
  1676.   } // Pass EVERYTHING else through.
  1677.   lpLine[iDest]=lpBuffer[fifoWalker];
  1678.   fifoWalker=(fifoWalker+1)%iMax;
  1679.   iDest++;
  1680.  }
  1681.  lpLine[iDest]='\0';    // Zero terminate it, for luck
  1682.  
  1683.  lpClient->fifoInputStart=fifoWalker;
  1684.  
  1685.  smtpLog(LOG_HIGH, LOG_RECEIVED_S, (LPCSTR)lpLine);
  1686.  return(iDest);              // Tell em how many we copied!
  1687. } /* clientReceiveBlock */
  1688.  
  1689. /**** End of WSMTPSRV.C ****/
  1690.