开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
Parser.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：48k
源码类别：

传真(Fax)编程

开发平台：

C/C++

Parser.c++：源码内容
  1. /* $Id: Parser.c++,v 1.15 2009/03/02 04:54:14 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1995-1996 Sam Leffler
  4.  * Copyright (c) 1995-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  27. /*
  28.  * HylaFAX Client-Server Protocol Parser.
  29.  */
  30. #include "port.h"
  31. #include "config.h"
  32. #include "Sys.h"
  33. #include "Socket.h"
  34. #include "HylaFAXServer.h"
  35. #include "Dispatcher.h"
  37. #include <ctype.h>
  39. #define N(a) (sizeof (a) / sizeof (a[0]))
  41. /*
  42.  * Standard protocol commands.
  43.  */
  44. static const tab cmdtab[] = {
  45. { "ABOR",         T_ABOR, false, true, "[modem] (abort operation)" },
  46. { "ACCT",         T_ACCT, false,false, "(specify account)" },
  47. { "ADMIN",        T_ADMIN,  true, true, "password" },
  48. { "ALLO",         T_ALLO, false,false, "(allocate disk space)" },
  49. { "ANSWER",       T_ANSWER,  true, true, "modem [DATA|VOICE|FAX]" },
  50. { "APPE",         T_APPE,  true, true, "file-name" },
  51. { "CWD",          T_CWD,  true, true, "[directory-name]" },
  52. { "CDUP",         T_CDUP,  true, true, "(change directory up one level)"},
  53. { "CHMOD",        T_CHMOD,  true, true, "file-name mode" },
  54. { "CHOWN",        T_CHOWN,  true, true, "file-name user" },
  55. { "DELE",         T_DELE,  true, true, "file-name" },
  56. { "DISABLE",      T_DISABLE,  true, true, "modem [reason]" },
  57. { "ENABLE",       T_ENABLE,  true, true, "modem" },
  58. { "EPRT",         T_EPRT,  true, true, "|f|addr|port|" },
  59. { "EPSV",         T_EPSV,  true, true, "(set server in passive mode with extended result)" },
  60. { "HELP",         T_HELP, false, true, "[<string>]" },
  61. { "FILEFMT",      T_FILEFMT,  true, true, "[format-string]" },
  62. { "FORM",         T_FORM,  true, true, "format-type" },
  63. { "IDLE",         T_IDLE,  true, true, "[max-idle-timeout]" },
  64. { "JDELE",        T_JDELE,  true, true, "[job-id]" },
  65. { "JINTR",        T_JINTR,  true, true, "[job-id]" },
  66. { "JKILL",        T_JKILL,  true, true, "[job-id]" },
  67. { "JNEW",         T_JNEW,  true, true, "" },
  68. { "JOB",          T_JOB,  true, true, "[job-id]" },
  69. { "JOBFMT",       T_JOBFMT,  true, true, "[format-string]" },
  70. { "JPARM",        T_JPARM,  true, true, "[parm-name [parm-value]]" },
  71. { "JREST",        T_JREST,  true, true, "(reset current job state)" },
  72. { "JSUBM",        T_JSUB,  true, true, "[job-id]" },
  73. { "JSUSP",        T_JSUSP,  true, true, "[job-id]" },
  74. { "JWAIT",        T_JWAIT,  true, true, "[job-id]" },
  75. { "JGDELE",       T_JGDELE,  true,false, "[jobgroup-id]" },
  76. { "JGINTR",       T_JGINTR,  true,false, "[jobgroup-id]" },
  77. { "JGKILL",       T_JGKILL,  true,false, "[jobgroup-id]" },
  78. { "JGNEW",        T_JGNEW,  true, true, "" },
  79. { "JGPARM",       T_JGPARM,  true,false, "parm-name [parm-value]" },
  80. { "JGREST",       T_JGREST,  true,false, "(reset current job group state)"},
  81. { "JGRP",         T_JGRP,  true,false, "[jobgroup-id]" },
  82. { "JGSUBM",       T_JGSUB,  true,false, "[jobgroup-id]" },
  83. { "JGSUSP",       T_JGSUSP,  true,false, "[jobgroup-id]" },
  84. { "JGWAIT",       T_JGWAIT,  true,false, "[jobgroup-id]" },
  85. { "LIST",         T_LIST,  true, true, "[path-name]" },
  86. { "MDTM",         T_MDTM,  true, true, "path-name" },
  87. { "MODE",         T_MODE, false, true, "(specify transfer mode)" },
  88. { "MDMFMT",       T_MODEMFMT,  true, true, "[format-string]" },
  89. { "NLST",         T_NLST,  true, true, "[path-name]" },
  90. { "NOOP",         T_NOOP, false, true, "" },
  91. { "PASS",         T_PASS, false, true, "password" },
  92. { "PASV",         T_PASV,  true, true, "(set server in passive mode)" },
  93. { "PORT",         T_PORT,  true, true, "a0,a1,a2,a3,p0,p1" },
  94. { "PWD",          T_PWD,  true, true, "(print working directory)" },
  95. { "QUIT",         T_QUIT, false, true, "(terminate service)", },
  96. { "RCVFMT",       T_RCVFMT,  true, true, "[format-string]" },
  97. { "REIN",         T_REIN, false, true, "(reinitialize server state)" },
  98. { "REST",         T_REST,  true, true, "restart-marker" },
  99. { "RETP",         T_RETP,  true, true, "file-name" },
  100. { "RETR",         T_RETR,  true, true, "file-name" },
  101. { "RNFR",         T_RNFR,  true,false, "file-name" },
  102. { "RNTO",         T_RNTO,  true,false, "file-name" },
  103. { "SHUT",         T_SHUT,  true, true, "NOW|HHSS|YYYYMMDDHHSS [reason]" },
  104. { "SITE",         T_SITE,  true, true, "site-cmd [arguments]" },
  105. { "SIZE",         T_SIZE,  true, true, "path-name" },
  106. { "STAT",         T_STAT, false, true, "[path-name]" },
  107. { "STOR",         T_STOR,  true, true, "file-name" },
  108. { "STOT",         T_STOT,  true, true, "(store unique temporary)" },
  109. { "STOU",         T_STOU,  true, true, "(store unique)" },
  110. { "STRU",         T_STRU, false, true, "file-structure" },
  111. { "SYST",         T_SYST,  true, true, "(return system type)" },
  112. { "TZONE",        T_TZONE,  true, true, "[GMT|LOCAL]" },
  113. { "TYPE",         T_TYPE, false, true, "transfer-type" },
  114. { "USER",         T_USER, false, true, "username" },
  115. { "VRFY",         T_VRFY, false, true, "dialstring" },
  116. };
  118. /*
  119.  * Job parameter commands/keys.
  120.  */
  121. static const tab parmtab[] = {
  122. { "ACCTINFO",     T_ACCTINFO,   false,false, "[<string>]" },
  123. { "BEGBR",        T_BEGBR,   false, true, "[ANY|bit-rate]" },
  124. { "BEGST",        T_BEGST,   false, true, "[ANY|scanline-time]" },
  125. { "CHOPTHRESHOLD",T_CHOPTHRESH,   false, true, "[inches]" },
  126. { "CLIENT",       T_CLIENT,   false, true, "[<string>]" },
  127. { "COMMENTS",     T_COMMENTS,   false, true, "[<string>]" },
  128. { "COMMID",       T_COMMID,   false, true, "(communication identifier)" },
  129. { "COVER",        T_COVER,   false, true, "path-name" },
  130. { "DATAFORMAT",   T_DATAFORMAT,   false, true, "[ANY|G31D|G32D|G4]" },
  131. { "DIALSTRING",   T_DIALSTRING,   false, true, "[<string>]" },
  132. { "DOCUMENT",     T_DOCUMENT,   false, true, "path-name" },
  133. { "DONEOP",       T_DONEOP,   false, true, "[<string>]" },
  134. { "ERRORCODE",    T_ERRORCODE,    false, true, "[<string>]" },
  135. { "EXTERNAL",     T_EXTERNAL,   false, true, "[<string>]" },
  136. { "FAXNUMBER",    T_FAXNUMBER,   false, true, "[<string>]" },
  137. { "FAXNAME",      T_FAXNAME,   false, true, "[<string>]" },
  138. { "FROMCOMPANY",  T_FROM_COMPANY, false, true, "[<string>]" },
  139. { "FROMLOCATION", T_FROM_LOCATION,false, true, "[<string>]" },
  140. { "FROMUSER",     T_FROM_USER,   false, true, "[<string>]" },
  141. { "FROMVOICE",    T_FROM_VOICE,   false, true, "[<string>]" },
  142. { "GROUPID",      T_GROUPID,   false, true, "(job group identifier)" },
  143. { "HRES",         T_HRES,   false,false, "[dots-per-inch]" },
  144. { "IGNOREMODEMBUSY", T_IGNOREMODEMBUSY, false, true, "[YES|NO]" },
  145. { "JOBID",        T_JOBID,   false, true, "(job identifier)" },
  146. { "JOBINFO",      T_JOBINFO,   false, true, "[<string>]" },
  147. { "JOBTYPE",      T_JOBTYPE,   false, true, "(job type)" },
  148. { "LASTTIME",     T_LASTTIME,   false, true, "[DDHHSS]" },
  149. { "MAXDIALS",     T_MAXDIALS,   false, true, "[<number>]" },
  150. { "MAXPAGES",     T_MAXPAGES,   false, true, "[<number>]" },
  151. { "MAXTRIES",     T_MAXTRIES,   false, true, "[<number>]" },
  152. { "MINBR",        T_MINBR,   false, true, "[ANY|bit-rate]" },
  153. { "MODEM",        T_MODEM,   false, true, "[device|class]" },
  154. { "NDIALS",       T_NDIALS,   false, true, "[<number>]" },
  155. { "NOCOUNTCOVER", T_NOCOUNTCOVER, false, true, "[<number>]" },
  156. { "SERVERDOCOVER", T_SERVERDOCOVER, false, true, "[YES|NO]" },
  157. { "NOTIFY",       T_NOTIFY,   false, true, "[NONE|DONE|REQUEUE|DONE+REQUEUE]" },
  158. { "NOTIFYADDR",   T_NOTIFYADDR,   false, true, "[email-address]" },
  159. { "NPAGES",       T_NPAGES,   false, true, "[<number>]" },
  160. { "NTRIES",       T_NTRIES,   false, true, "[<number>]" },
  161. { "OWNER",        T_OWNER,   false, true, "[<name>|<number>]" },
  162. { "PAGECHOP",     T_PAGECHOP,   false, true, "[DEFAULT|NONE|ALL|LAST]" },
  163. { "PAGELENGTH",   T_PAGELENGTH,   false, true, "[millimeters]" },
  164. { "PAGEWIDTH",    T_PAGEWIDTH,   false, true, "[millimeters]" },
  165. { "PASSWD",       T_PASSWD,   false, true, "[<string>]" },
  166. { "POLL",         T_POLL,   false, true, "selector [passwd]" },
  167. { "REGARDING",    T_REGARDING,   false, true, "[<string>]" },
  168. { "RETRYTIME",    T_RETRYTIME,   false, true, "[HHSS]" },
  169. { "SCHEDPRI",     T_SCHEDPRI,   false, true, "[<number>]" },
  170. { "SENDTIME",     T_SENDTIME,   false, true, "[NOW|YYYYMMDDHHSS]" },
  171. { "SKIPPAGES",    T_SKIPPAGES,    false, true, "[<number>]" },
  172. { "SKIPPEDPAGES", T_SKIPPEDPAGES, false, true, "[<number>]" },
  173. { "STATE",        T_STATE,   false, true, "(job state)" },
  174. { "STATUS",       T_STATUS,       false, true, "[<string>]" },
  175. { "SUBADDR",      T_SUBADDR,   false, true, "[<string>]" },
  176. { "TAGLINE",      T_TAGLINE,   false, true, "[<string>]" },
  177. { "TIMEOFDAY",    T_TIMEOFDAY,   false, true, "[<string>]" },
  178. { "TOCOMPANY",    T_TO_COMPANY,   false, true, "[<string>]" },
  179. { "TOLOCATION",   T_TO_LOCATION,  false, true, "[<string>]" },
  180. { "TOTDIALS",     T_TOTDIALS,   false, true, "[<number>]" },
  181. { "TOTPAGES",     T_TOTPAGES,   false, true, "[<number>]" },
  182. { "TOTTRIES",     T_TOTTRIES,   false, true, "[<number>]" },
  183. { "TOUSER",       T_TO_USER,   false, true, "[<string>]" },
  184. { "TOVOICE",      T_TO_VOICE,   false, true, "[<string>]" },
  185. { "TSI",          T_TSI,   false, true, "[<string>]" },
  186. { "USECONTCOVER", T_USE_CONTCOVER,false, true, "[YES|NO]" },
  187. { "USEXVRES",     T_USE_XVRES,   false, true, "[YES|NO]" },
  188. { "USEECM",       T_USE_ECM,   false, true, "[YES|NO]" },
  189. { "ECMTYPE",      T_ECMTYPE,   false, true, "[64BIT|256BIT|HALFDUPLEX|FULLDUPLEX]" },
  190. { "USETAGLINE",   T_USE_TAGLINE,  false, true, "[YES|NO]" },
  191. { "USRKEY",       T_USRKEY,   false, true, "[<string>]" },
  192. { "VRES",         T_VRES,   false, true, "[lines-per-inch]" },
  194. { "HELP",         T_HELP,   false, true, "[<string>]" },
  195. };
  197. /*
  198.  * Site-specific commands.
  199.  */
  200. static const tab sitetab[] = {
  201. { "ADDMODEM",     T_ADDMODEM,   false,false, "modem [speed]"},
  202. { "ADDUSER",      T_ADDUSER,   false, true, "user-spec [passwd [adminwd]]"},
  203. { "CONFIG",       T_CONFIG,   false, true, "[parm-name [parm-value]]" },
  204. { "DELMODEM",     T_DELMODEM,   false,false, "modem" },
  205. { "DELUSER",      T_DELUSER,   false, true, "user-spec" },
  206. { "TRIGGER",   T_TRIGGER,   false, true, "spec" },
  207. { "HELP",         T_HELP,   false, true, "[<string>]" },
  208. { "LOCKWAIT",     T_LOCKWAIT,   false, true, "max-lockwait-timeout" },
  209. };
  211. static const tab*
  212. lookup(const tab* p, u_int n, const char* cmd)
  213. {
  214.     while (n != 0) {
  215.         if (strcmp(cmd, p->name) == 0)
  216.             return (p);
  217. p++, n--;
  218.     }
  219.     return (NULL);
  220. }
  221. static const char*
  222. tokenName(const tab* p, u_int n, Token t)
  223. {
  224.     while (n != 0) {
  225. if (p->token == t)
  226.     return (p->name);
  227. p++, n--;
  228.     }
  229.     return ("???");
  230. }
  231. const char*
  232. HylaFAXServer::cmdToken(Token t)
  233. {
  234.     return tokenName(cmdtab, N(cmdtab), t);
  235. }
  236. const char*
  237. HylaFAXServer::siteToken(Token t)
  238. {
  239.     return tokenName(sitetab, N(sitetab), t);
  240. }
  241. const char*
  242. HylaFAXServer::parmToken(Token t)
  243. {
  244.     return tokenName(parmtab, N(parmtab), t);
  245. }
  247. u_int
  248. HylaFAXServer::twodigits(const char* cp, u_int range)
  249. {
  250.     return ((cp[0]-'0')*10 + (cp[1]-'0')) % range;
  251. }
  252. u_int
  253. HylaFAXServer::fourdigits(const char* cp)
  254. {
  255.     return (cp[0]-'0')*1000 +
  256.    (cp[1]-'0')*100 +
  257.    (cp[2]-'0')*10 +
  258.    (cp[3]-'0');
  259. }
  260. inline bool
  261. isLoginToken(Token t)
  262. {
  263.     return (t == T_USER || t == T_PASS || t == T_ADMIN);
  264. }
  266. /*
  267.  * Parse and process command input received on the
  268.  * control channel.  This method is invoked whenever
  269.  * data is present on the control channel.  We read
  270.  * everything and parse (and execute) as much as possible
  271.  * but do not block waiting for more data except when
  272.  * a partial line of input is received.  This is done
  273.  * to ensure other processing will be handled in a
  274.  * timely fashion (e.g. processing of messages from
  275.  * the scheduler received via the FIFO).
  276.  */
  277. int
  278. HylaFAXServer::parse()
  279. {
  280.     if (IS(WAITDATA)) { // recursive invocation
  281. state &= ~S_WAITDATA;
  282. return (0);
  283.     }
  284. // stop control channel idle timeout
  285.     Dispatcher::instance().stopTimer(this);
  286.     pushToken(T_NIL); // reset state
  287.     for (;;) {
  288. /*
  289.  * Fetch the next complete line of input received on the
  290.  * control channel.  This call will fail when no more data
  291.  * is *currently* waiting on the control channel.  Note
  292.  * that this does not mean the connection has dropped; just
  293.  * that data is not available at this instant.  Note also
  294.  * that if a partial line of input is received a complete
  295.  * line will be waited for (see below).
  296.  */
  297. if (!getCmdLine(cbuf, sizeof (cbuf)))
  298.     break;
  299. /*
  300.  * Parse the line of input read above.
  301.  */
  302. if (getToken(T_STRING, "command token")) {
  303.     tokenBody.raisecase();
  304.     const tab* p = lookup(cmdtab, N(cmdtab), tokenBody);
  305.     if (p == NULL)
  306. reply(500, "%s: Command not recognized.",
  307.     (const char*) tokenBody);
  308.     else if (!p->implemented)
  309. reply(502, "%s: Command not implemented.", p->name);
  310.     /*
  311.      * If the user is not privileged, then check for
  312.      * the service being shutdown if the command is
  313.      * not part of the login procedure (USER-PASS-ADMIN).
  314.      * This permits administrators to gain access to
  315.      * a system that is shutdown.  Other users will get
  316.      * dropped if they type something else.
  317.      */ 
  318.     else if (!IS(PRIVILEGED) && !isLoginToken(p->token) &&
  319.       isShutdown(!IS(LOGGEDIN))) {
  320. reply(221, "Server shutting down.  Goodbye.");
  321. dologout(0); // XXX
  322.     /*
  323.      * If command requires client to be logged in check
  324.      * for this.  Note that some commands have variants
  325.      * that do not require the client be logged in--these
  326.      * cannot check here and must do it specially below.
  327.      */
  328.     } else if (p->checklogin && !checklogin(p->token))
  329. ;
  330.     /*
  331.      * Command is valid, implemented, and the server
  332.      * is available to service it.  If the syntax is
  333.      * correct then reset the number of consecutive
  334.      * bad commands.  Note that since part of the syntax
  335.      * checking is login validation this logic will also
  336.      * catch people typing syntacitcally valid but
  337.      * unacceptable commands just to remain connected.
  338.      */
  339.     else if (cmd(p->token)) {
  340. if (p->token != T_REST)
  341.     restart_point = 0;
  342. consecutiveBadCmds = 0;
  343. continue;
  344.     }
  345. }
  346. /*
  347.  * If too many consecutive bad commands have been
  348.  * received disconnect.  This is to safeguard against
  349.  * a client that spews trash down the control connection.
  350.  */
  351. if (++consecutiveBadCmds >= maxConsecutiveBadCmds) {
  352.     /*
  353.      * Check for shutdown so that any shutdown message
  354.      * will get prepended to client reply.
  355.      */
  356.     (void) isShutdown(!IS(LOGGEDIN));
  357.     reply(221, "Server shutting down.  Goodbye.");
  358.     dologout(0);
  359. }
  360.     }
  361.     Dispatcher::instance().startTimer(idleTimeout, 0, this);
  362.     return (0);
  363. }
  365. /*
  366.  * Protocol command (one line).
  367.  */
  368. bool
  369. HylaFAXServer::cmd(Token t)
  370. {
  371.     fxStr s;
  372.     long n;
  374.     switch (t) {
  375.     case T_USER: // user name
  376. if (multi_string_param(s, "user name")) {
  377.     logcmd(t, "%s", (const char*) s);
  378.     userCmd(s);
  379.     return (true);
  380. }
  381. break;
  382.     case T_PASS: // user password
  383. if (multi_string_param(s, "password")) {
  384.     logcmd(t, "<password>");
  385.     passCmd(s);
  386.     return (true);
  387. }
  388. break;
  389.     case T_ADMIN: // administrator password
  390. if (opt_CRLF())
  391.     s = "";
  392. else if (!multi_string_param(s, "password"))
  393.     break;
  394. logcmd(t, "<password>");
  395. adminCmd(s);
  396. return (true);
  397.     case T_REIN: // reinitialize server
  398. logcmd(t);
  399. if (IS(LOGGEDIN))
  400.     int ignore = chdir("/"); // return to top of spooling area
  401. initServer();
  402. reply(220, "%s server (%s) ready.", (const char*) hostname, version);
  403. break;
  404.     case T_REST: // restart data transfer
  405. if (number_param(n)) {
  406.     logcmd(t, "%lu", n);
  407.     restart_point = n;
  408.     reply(350, "Data transfer will restart at %lu, "
  409. "send transfer command", n);
  410.     return (true);
  411. }
  412. break;
  413.     case T_SYST: // system identification
  414. if (CRLF()) {
  415.     logcmd(t);
  416.     // this is what we *emulate*
  417.     reply(215, "%s", (const char*) systemType);
  418.     return (true);
  419. }
  420. break;
  421.     case T_EPRT: // extended port for data transfer
  422.     case T_PORT: // port for data transfer
  423. if (SPACE() && hostPort() && CRLF()) {
  424.     portCmd(t);
  425.     return (true);
  426. }
  427. break;
  428.     case T_EPSV: // extended passive mode
  429.     case T_PASV: // enable passive mode
  430. if (CRLF()) {
  431.     logcmd(t);
  432.     passiveCmd();
  433.     return (true);
  434. }
  435. break;
  436.     case T_FORM: // document format
  437. if (string_param(s, "document format")) {
  438.     logcmd(t, "%s", (const char*) s);
  439.     formCmd(s);
  440.     return (true);
  441. }
  442. break;
  443.     case T_MODE: // data transfer mode
  444. if (string_param(s, "transfer mode")) {
  445.     logcmd(t, "%s", (const char*) s);
  446.     modeCmd(s);
  447.     return (true);
  448. }
  449. break;
  450.     case T_STRU: // data transfer file structure
  451. if (string_param(s, "file structure")) {
  452.     logcmd(t, "%s", (const char*) s);
  453.     struCmd(s);
  454.     return (true);
  455. }
  456. break;
  457.     case T_TYPE: // data transfer type
  458. if (string_param(s, "transfer type")) {
  459.     logcmd(t, "%s", (const char*) s);
  460.     typeCmd(s);
  461.     return (true);
  462. }
  463. break;
  464.     case T_RETP: // retrieve next page of document/file
  465. if (pathname_param(s)) {
  466.     logcmd(t, "%s", (const char*) s);
  467.     retrievePageCmd(s);
  468.     return (true);
  469. }
  470. break;
  471.     case T_RETR: // retrieve document/file
  472. if (pathname_param(s)) {
  473.     logcmd(t, "%s", (const char*) s);
  474.     retrieveCmd(s);
  475.     return (true);
  476. }
  477. break;
  478.     case T_STOR: // store document/file
  479. if (pathname_param(s)) {
  480.     logcmd(t, "%s", (const char*) s);
  481.     // XXX file must exist if not admin, check for bad chars in pathname
  482.     storeCmd(s, "w");
  483.     return (true);
  484. }
  485. break;
  486.     case T_APPE: // append to document/file
  487. if (pathname_param(s)) {
  488.     logcmd(t, "%s", (const char*) s);
  489.     storeCmd(s, "a");
  490.     return (true);
  491. }
  492. break;
  493.     case T_STOT: // store uniquely named document/file
  494. if (CRLF()) {
  495.     logcmd(t);
  496.     storeUniqueCmd(true);
  497.     return (true);
  498. }
  499. break;
  500.     case T_STOU: // store uniquely named document/file
  501. if (CRLF()) {
  502.     logcmd(t);
  503.     storeUniqueCmd(false);
  504.     return (true);
  505. }
  506. break;
  507.     case T_LIST: // list directory/file
  508.     case T_NLST: // list directory/file names
  509. if (opt_CRLF()) {
  510.     logcmd(t);
  511.     if (t == T_LIST)
  512. listCmd(".");
  513.     else
  514. nlstCmd(".");
  515.     return (true);
  516. } else if (pathname_param(s)) {
  517.     logcmd(t, "%s", (const char*) s);
  518.     if (t == T_LIST)
  519. listCmd(s);
  520.     else
  521. nlstCmd(s);
  522.     return (true);
  523. }
  524. break;
  525.     case T_CWD: // change working directory
  526. if (opt_CRLF()) {
  527.     logcmd(t);
  528.     cwdCmd("/");
  529.     return (true);
  530. } else if (pathname_param(s)) {
  531.     logcmd(t, "%s", (const char*) s);
  532.     cwdCmd(s);
  533.     return (true);
  534. }
  535. break;
  536.     case T_CDUP: // CWD ..
  537. logcmd(t);
  538. cwdCmd("..");
  539. return (true);
  540.     case T_PWD: // print working directory
  541. if (CRLF()) {
  542.     logcmd(t);
  543.     pwdCmd();
  544.     return (true);
  545. }
  546. break;
  547.     case T_STAT: // stat file/server status
  548. if (opt_CRLF()) {
  549.     logcmd(t);
  550.     statusCmd();
  551.     return (true);
  552. } else if (checklogin(T_STAT) && pathname_param(s)) {
  553.     logcmd(t, "%s", (const char*) s);
  554.     statFileCmd(s);
  555.     return (true);
  556. }
  557. break;
  558.     case T_SIZE: // return file size
  559. if (pathname_param(s)) {
  560.     logcmd(t, "%s", (const char*) s);
  561.     struct stat sb;
  562.     if (Sys::stat(s, sb) < 0 || (sb.st_mode&S_IFMT) != S_IFREG)
  563. reply(550, "%s: not a plain file.", (const char*) s);
  564.     else
  565. reply(213, "%lu", (u_long) sb.st_size);
  566.     return (true);
  567. }
  568. break;
  569.     case T_CHMOD: // set file protection
  570. if (SPACE() && STRING(s, "filename") && SPACE() && NUMBER(n)) {
  571.     chmodCmd(s, (u_int) n);
  572.     return (true);
  573. }
  574. break;
  575.     case T_MDTM: // return file last modification time
  576. if (pathname_param(s)) {
  577.     logcmd(t, "%s", (const char*) s);
  578.     mdtmCmd(s);
  579.     return (true);
  580. }
  581. break;
  582.     case T_DELE: // delete file/document
  583. if (pathname_param(s)) {
  584.     logcmd(t, "%s", (const char*) s);
  585.     deleCmd(s);
  586.     return (true);
  587. }
  588. break;
  589.     case T_ABOR: // abort active command/incoming call
  590. if (opt_CRLF()) {
  591.     logcmd(t);
  592.     ack(225, cmdToken(t));
  593.     return (true);
  594. } else if (checkadmin(T_ABOR) && string_param(s, "modem")) {
  595.     abortCallCmd(s);
  596.     return (true);
  597. }
  598. break;
  599.     case T_HELP: // return help
  600. if (opt_CRLF()) {
  601.     logcmd(t);
  602.     helpCmd(cmdtab, (char*) NULL);
  603.     return (true);
  604. } else if (string_param(s, "command name")) {
  605.     logcmd(t, "%s", (const char*) s);
  606.     s.raisecase();
  607.     if (s == "SITE")
  608. helpCmd(sitetab, NULL);
  609.     else if (s == "JPARM" || s == "JGPARM")
  610. helpCmd(parmtab, NULL);
  611.     else
  612. helpCmd(cmdtab, s);
  613.     return (true);
  614. }
  615. break;
  616.     case T_JNEW: // create new job
  617. if (CRLF()) {
  618.     newJobCmd();
  619.     return (true);
  620. }
  621. break;
  622.     case T_JOB: // select current job
  623. if (job_param(s)) {
  624.     setCurrentJob(s);
  625.     return (true);
  626. }
  627. break;
  628.     case T_JREST: // reset job state
  629. if (job_param(s)) {
  630.     resetJob(s);
  631.     return (true);
  632. }
  633. break;
  634.     case T_JDELE: // delete job
  635. if (job_param(s)) {
  636.     deleteJob(s);
  637.     return (true);
  638. }
  639. break;
  640.     case T_JINTR: // interrupt job
  641. if (job_param(s)) {
  642.     interruptJob(s);
  643.     return (true);
  644. }
  645. break;
  646.     case T_JKILL: // kill job
  647. if (job_param(s)) {
  648.     killJob(s);
  649.     return (true);
  650. }
  651. break;
  652.     case T_JSUSP: // suspend job
  653. if (job_param(s)) {
  654.     suspendJob(s);
  655.     return (true);
  656. }
  657. break;
  658.     case T_JSUB: // submit job
  659. if (job_param(s)) {
  660.     submitJob(s);
  661.     return (true);
  662. }
  663. break;
  664.     case T_JWAIT: // wait for job
  665. if (job_param(s)) {
  666.     waitForJob(s);
  667.     return (true);
  668. }
  669. break;
  670.     case T_JGNEW: // create job group
  671. if (CRLF()) {
  672.     curJob->groupid = curJob->jobid;
  673.     ack(200, cmdToken(t));
  674.     return (true);
  675. }
  676. break;
  677.     case T_JGREST: // reset current job group state
  678. if (CRLF()) {
  679.     return (true);
  680. }
  681. break;
  682.     case T_JGRP: // select current job group
  683. if (jgrp_param(s)) {
  684.     return (true);
  685. }
  686. break;
  687.     case T_JGDELE: // delete job group
  688. if (jgrp_param(s)) {
  689.     return (true);
  690. }
  691. break;
  692.     case T_JGINTR: // interrupt job group
  693. if (jgrp_param(s)) {
  694.     return (true);
  695. }
  696. break;
  697.     case T_JGKILL: // kill job group
  698. if (jgrp_param(s)) {
  699.     return (true);
  700. }
  701. break;
  702.     case T_JGSUSP: // suspend job group
  703. if (jgrp_param(s)) {
  704.     return (true);
  705. }
  706. break;
  707.     case T_JGSUB: // submit job group
  708. if (jgrp_param(s)) {
  709.     return (true);
  710. }
  711. break;
  712.     case T_JGWAIT: // wait for job group
  713. if (jgrp_param(s)) {
  714.     return (true);
  715. }
  716. break;
  717.     case T_NOOP: // no-op
  718. if (CRLF()) {
  719.     logcmd(t);
  720.     ack(200, cmdToken(t));
  721.     return (true);
  722. }
  723. break;
  724.     case T_IDLE: // set/query idle timeout
  725. if (opt_CRLF()) {
  726.     logcmd(t);
  727.     reply(213, "%u seconds.", idleTimeout);
  728.     return (true);
  729. } else if (number_param(n)) {
  730.     logcmd(t, "%lu", n);
  731.     if ((unsigned)n > maxIdleTimeout && !IS(PRIVILEGED)) {
  732. idleTimeout = maxIdleTimeout;
  733. reply(213, "%lu: Idle timeout too large, set to %u.",
  734.     n, maxIdleTimeout);
  735.     } else {
  736. idleTimeout = (int) n;
  737. reply(213, "Idle timeout set to %u.", idleTimeout);
  738.     }
  739.     return (true);
  740. }
  741. break;
  742.     case T_QUIT: // terminate session
  743. if (CRLF()) {
  744.     logcmd(t);
  745.     reply(221, "Goodbye.");
  746.     dologout(0);
  747.     return (true);
  748. }
  749. break;
  750.     case T_TZONE: // set/query timezone usage
  751. if (opt_CRLF()) {
  752.     reply(200, "Time values are handled in %s.", 
  753. IS(USEGMT) ? "GMT" : tzname[0]);
  754.     return (true);
  755. } else if (string_param(s, "timezone specification")) {
  756.     logcmd(t, "%s", (const char*) s);
  757.     s.raisecase();
  758.     if (s == "GMT") {
  759. state |= S_USEGMT;
  760. reply(200, "Using time values in GMT.");
  761.     } else if (s == "LOCAL") {
  762. state &= ~S_USEGMT;
  763. reply(200, "Using time values in %s.", tzname[0]);
  764.     } else {
  765. reply(503, "Unknown timezone specification %s.",
  766.     (const char*) s);
  767.     }
  768.     return (true);
  769. }
  770. break;
  771.     case T_JOBFMT: // query/specify job format string
  772.     case T_RCVFMT: // query/specify recvq format string
  773.     case T_MODEMFMT: // query/specify modem format string
  774.     case T_FILEFMT: // query/specify file format string
  775. if (opt_CRLF()) {
  776.     reply(200, "%s",
  777. t == T_JOBFMT ?   (const char*) jobFormat :
  778. t == T_RCVFMT ?   (const char*) recvFormat:
  779. t == T_MODEMFMT ? (const char*) modemFormat :
  780.   (const char*) fileFormat
  781.     );
  782.     return (true);
  783. } else if (string_param(s, "format-string")) {
  784.     if (t == T_JOBFMT)
  785. jobFormat = s;
  786.     else if (t == T_RCVFMT)
  787. recvFormat = s;
  788.     else if (t == T_MODEMFMT)
  789. modemFormat = s;
  790.     else if (t == T_FILEFMT)
  791. fileFormat = s;
  792.     ack(200, cmdToken(t));
  793.     return (true);
  794. }
  795. break;
  796.     case T_JPARM: // set/query job parameter
  797. if (opt_CRLF()) {
  798.     logcmd(T_JPARM);
  799.     if (checkJobState(curJob))
  800. jstatCmd(*curJob);
  801.     return (true);
  802. } else if (SPACE() && getToken(T_STRING, "parameter name")) {
  803.     tokenBody.raisecase();
  804.     const tab* p = lookup(parmtab, N(parmtab), tokenBody);
  805.     if (p == NULL) {
  806. reply(500, "JPARM %s: Parameter not recognized.",
  807.     (const char*) tokenBody);
  808.     } else if (!p->implemented)
  809. reply(502, "JPARM %s: Parameter not implemented.", p->name);
  810.     else
  811. return (param_cmd(p->token));
  812. }
  813. break;
  814.     case T_JGPARM: // set/query job group parameter
  815. if (SPACE() && getToken(T_STRING, "parameter name")) {
  816.     tokenBody.raisecase();
  817.     const tab* p = lookup(parmtab, N(parmtab), tokenBody);
  818.     if (p == NULL) {
  819. reply(500, "JPARM %s: Parameter not recognized.",
  820.     (const char*) tokenBody);
  821.     } else if (!p->implemented)
  822. reply(502, "JPARM %s: Parameter not implemented.", p->name);
  823.     else
  824. return (param_cmd(p->token));
  825. }
  826. break;
  827.     case T_SITE: // site-specific command
  828. if (SPACE() && getToken(T_STRING, "site command")) {
  829.     tokenBody.raisecase();
  830.     const tab* p = lookup(sitetab, N(sitetab), tokenBody);
  831.     if (p == NULL) {
  832. reply(500, "SITE %s: Command not recognized.",
  833.     (const char*) tokenBody);
  834.     } else if (!p->implemented)
  835. reply(502, "SITE %s: Command not implemented.", p->name);
  836.     else
  837. return (site_cmd(p->token));
  838. }
  839. break;
  840.     case T_ANSWER: // answer phone on specific line
  841. if (checkadmin(T_ANSWER) && SPACE() && STRING(s, "modem")) {
  842.     fxStr how;
  843.     if (opt_CRLF())
  844. how = "any";
  845.     else if (!string_param(how, "answer-how"))
  846. break;
  847.     answerCallCmd(s, how);
  848.     return (true);
  849. }
  850. break;
  851.     case T_CHOWN: // assign file ownership
  852. if (checkadmin(T_CHOWN) && SPACE() && STRING(s, "filename")) {
  853.     fxStr who;
  854.     if (string_param(who, "user")) {
  855. chownCmd(s, who);
  856. return (true);
  857.     }
  858. }
  859. break;
  860.     case T_DISABLE: // disable outbound-usage of modem
  861. if (checkadmin(T_DISABLE) && SPACE() && STRING(s, "modem")) {
  862.     fxStr reason;
  863.     if (opt_CRLF())
  864. reason = "<unspecified reason>";
  865.     else if (!SPACE() || !multi_STRING(reason))
  866. break;
  867.     disableModemCmd(s, reason);
  868.     return (true);
  869. }
  870. break;
  871.     case T_ENABLE: // enable outbound-usage of modem
  872. if (checkadmin(T_ENABLE) && string_param(s, "modem")) {
  873.     enableModemCmd(s);
  874.     return (true);
  875. }
  876. break;
  877.     case T_SHUT: // shutdown server
  878. if (checkadmin(T_SHUT) && SPACE() && STRING(s, "shutdown-time")) {
  879.     fxStr reason;
  880.     if (opt_CRLF())
  881. reason = "<unspecified reason>";
  882.     else if (!SPACE() || !multi_STRING(reason))
  883. break;
  884.     const char* cp = s;
  885.     if (s.length() == 3 && strcasecmp(cp, "NOW") == 0) {
  886. time_t t = Sys::now();
  887. shutCmd(*localtime(&t), reason);
  888. return (true);
  889.     } else if (s.length() == 4 && checkNUMBER(cp)) {
  890. time_t t = Sys::now();
  891. struct tm tm = *localtime(&t);
  892. tm.tm_hour = 60*60*twodigits(cp, 60);
  893. tm.tm_min  =    60*twodigits(cp+2, 60);
  894. shutCmd(tm, reason);
  895. return (true);
  896.     } else if (s.length() == 12 && checkNUMBER(cp)) {
  897. struct tm tm;
  898. tm.tm_sec  = 0;
  899. tm.tm_min  = twodigits(cp+10, 60);
  900. tm.tm_hour = twodigits(cp+8, 24);
  901. tm.tm_mday = twodigits(cp+6, 31);
  902. tm.tm_mon  = twodigits(cp+4, 12) -1;
  903. tm.tm_year = fourdigits(cp+0) - 1900;
  904. shutCmd(tm, reason);
  905. return (true);
  906.     } else
  907. syntaxError("bad time specification");
  908. }
  909. break;
  910.     case T_VRFY: // verify server to use for destination
  911. if (string_param(s, "dialstring")) {
  912.     // XXX at least support a static file...
  913.     reply(200, "%s (%s)"
  914. , (const char*) hostname
  915. , (const char*) hostaddr
  916.     );
  917.     return (true);
  918. }
  919. break;
  920.     default:
  921. break;
  922.     }
  923.     return (false);
  924. }
  926. /*
  927.  * Site-specific protocol commands (one line).
  928.  */
  929. bool
  930. HylaFAXServer::site_cmd(Token t)
  931. {
  932.     fxStr s;
  933.     long n;
  935.     switch (t) {
  936.     case T_ADDUSER:
  937. if (checkadmin(T_ADDUSER) && SPACE() && STRING(s, "user-spec")) {
  938.     fxStr pass;
  939.     if (opt_CRLF()) {
  940. addUserCmd(s, "", "");
  941. return (true);
  942.     } else if (SPACE() && STRING(pass, "password")) {
  943. fxStr apass;
  944. if (opt_CRLF()) {
  945.     addUserCmd(s, pass, "");
  946.     return (true);
  947. } else if (string_param(apass, "admin-password")) {
  948.     addUserCmd(s, pass, apass);
  949.     return (true);
  950. }
  951.     }
  952. }
  953. break;
  954.     case T_DELUSER:
  955. if (checkadmin(T_DELUSER) && string_param(s, "user-spec")) {
  956.     delUserCmd(s);
  957.     return (true);
  958. }
  959. break;
  960.     case T_DELMODEM:
  961. if (checkadmin(T_DELMODEM) && string_param(s, "modem")) {
  962.     delModemCmd(s);
  963.     return (true);
  964. }
  965. break;
  966.     case T_ADDMODEM:
  967. if (checkadmin(T_ADDMODEM) && string_param(s, "modem")) {
  968.     addModemCmd(s);
  969.     return (true);
  970. }
  971. break;
  972.     case T_CONFIG:
  973. if (checkadmin(T_CONFIG) && SPACE() && STRING(s, "modem")) {
  974.     fxStr config;
  975.     if (opt_CRLF()) {
  976. configQueryCmd(s);
  977. return (true);
  978.     } else if (SPACE() && multi_STRING(config)) {
  979. configCmd(s, config);
  980. return (true);
  981.     }
  982. }
  983. break;
  984.     case T_TRIGGER:
  985. if (string_param(s, "trigger-spec")) {
  986.     logcmd(t, "%s", (const char*)s);
  987.     triggerCmd("%s", (const char*) s);
  988.     return (true);
  989. }
  990. break;
  991.     case T_HELP: // return help
  992. if (opt_CRLF()) {
  993.     helpCmd(sitetab, (char*) NULL);
  994.     return (true);
  995. } else if (string_param(s, "command name")) {
  996.     logcmd(T_SITE, "HELP %s", (const char*) s);
  997.     s.raisecase();
  998.     helpCmd(sitetab, s);
  999.     return (true);
  1000. }
  1001. break;
  1002.     case T_LOCKWAIT:
  1003. if (opt_CRLF()) {
  1004.     logcmd(t);
  1005.     reply(213, "%u seconds.", lockTimeout);
  1006.     return (true);
  1007. } else if (number_param(n)) {
  1008.     logcmd(t, "%lu", n);
  1009.     if ((unsigned)n > maxLockTimeout && !IS(PRIVILEGED)) {
  1010. lockTimeout = maxLockTimeout;
  1011. reply(213, "%lu: Lock timeout too large, set to %u.",
  1012.     n, maxLockTimeout);
  1013.     } else {
  1014. lockTimeout = (int) n;
  1015. reply(213, "Lock timeout set to %u.", lockTimeout);
  1016.     }
  1017.     return (true);
  1018. }
  1019.     default:
  1020. break;
  1021.     }
  1022.     return (false);
  1023. }
  1025. bool
  1026. HylaFAXServer::param_cmd(Token t)
  1027. {
  1028.     fxStr s;
  1029.     long n;
  1030.     time_t ticks;
  1031.     bool b;
  1033.     switch (t) {
  1034.     case T_SENDTIME: // time to send job
  1035. if (opt_CRLF()) {
  1036.     replyJobParamValue(*curJob, 213, t);
  1037.     return (true);
  1038. } else if (SPACE() && getToken(T_STRING, "time specification")) {
  1039.     tokenBody.raisecase();
  1040.     if (tokenBody == "NOW") {
  1041. if (CRLF() && setJobParameter(*curJob, t, (time_t) 0)) {
  1042.     reply(213, "%s set to NOW.", parmToken(t));
  1043.     return (true);
  1044. }
  1045.     } else {
  1046. pushToken(T_STRING); // XXX
  1047. if (TIMESPEC(12, ticks) && CRLF() &&
  1048.   setJobParameter(*curJob, t, ticks)) {
  1049.     if (ticks != 0) {
  1050. const struct tm* tm = cvtTime(ticks);
  1051. // XXX should response include seconds?
  1052. reply(213, "%s set to %4d%02d%02d%02d%02d%02d."
  1053.     , parmToken(t)
  1054.     , tm->tm_year+1900
  1055.     , tm->tm_mon+1
  1056.     , tm->tm_mday
  1057.     , tm->tm_hour
  1058.     , tm->tm_min
  1059.     , tm->tm_sec
  1060. );
  1061.     } else
  1062. reply(213, "%s set to NOW.", parmToken(t));
  1063.     return (true);
  1064. }
  1065.     }
  1066. }
  1067. break;
  1068.     case T_LASTTIME: // time to kill job
  1069. if (opt_CRLF()) {
  1070.     replyJobParamValue(*curJob, 213, t);
  1071.     return (true);
  1072. } else if (timespec_param(6, ticks) &&
  1073.   setJobParameter(*curJob, t, ticks)) {
  1074.     reply(213, "%s set to %02d%02d%02d."
  1075. , parmToken(t)
  1076. , ticks/(24*60*60)
  1077. , (ticks/(60*60))%24
  1078. , (ticks/60)%60
  1079.     );
  1080.     return (true);
  1081. }
  1082. break;
  1083.     case T_RETRYTIME: // retry interval for job
  1084. if (opt_CRLF()) {
  1085.     replyJobParamValue(*curJob, 213, t);
  1086.     return (true);
  1087. } else if (timespec_param(4, ticks) &&
  1088.   setJobParameter(*curJob, t, ticks)) {
  1089.     reply(213, "%s set to %02d%02d."
  1090. , parmToken(t)
  1091. , ticks/60
  1092. , ticks%60
  1093.     );
  1094.     return (true);
  1095. }
  1096. break;
  1097.     case T_MAXDIALS:
  1098.     case T_MAXTRIES:
  1099.     case T_VRES:
  1100.     case T_PAGEWIDTH:
  1101.     case T_PAGELENGTH:
  1102.     case T_MINBR:
  1103.     case T_BEGBR:
  1104.     case T_BEGST:
  1105.     case T_MAXPAGES:
  1106.     case T_SCHEDPRI:
  1107.     case T_NPAGES:
  1108.     case T_SKIPPAGES:
  1109.     case T_SKIPPEDPAGES:
  1110.     case T_NOCOUNTCOVER:
  1111.     case T_TOTPAGES:
  1112.     case T_NTRIES:
  1113.     case T_TOTTRIES:
  1114.     case T_NDIALS:
  1115.     case T_TOTDIALS:
  1116. if (opt_CRLF()) {
  1117.     replyJobParamValue(*curJob, 213, t);
  1118.     return (true);
  1119. } else if (number_param(n) &&
  1120.   setJobParameter(*curJob, t, (u_short) n)) {
  1121.     reply(213, "%s set to %u.", parmToken(t), n);
  1122.     return (true);
  1123. }
  1124. break;
  1125.     case T_NOTIFYADDR:
  1126.     case T_NOTIFY:
  1127.     case T_MODEM:
  1128.     case T_DIALSTRING:
  1129.     case T_EXTERNAL:
  1130.     case T_SUBADDR:
  1131.     case T_DATAFORMAT:
  1132.     case T_TO_USER:
  1133.     case T_TO_LOCATION:
  1134.     case T_TO_COMPANY:
  1135.     case T_TO_VOICE:
  1136.     case T_FROM_USER:
  1137.     case T_FROM_LOCATION:
  1138.     case T_FROM_COMPANY:
  1139.     case T_FROM_VOICE:
  1140.     case T_USRKEY:
  1141.     case T_PASSWD:
  1142.     case T_CLIENT:
  1143.     case T_PAGECHOP:
  1144.     case T_TAGLINE:
  1145.     case T_GROUPID:
  1146.     case T_JOBID:
  1147.     case T_JOBINFO:
  1148.     case T_OWNER:
  1149.     case T_STATE:
  1150.     case T_STATUS:
  1151.     case T_ERRORCODE:
  1152.     case T_DONEOP:
  1153.     case T_COMMID:
  1154.     case T_REGARDING:
  1155.     case T_COMMENTS:
  1156.     case T_TIMEOFDAY:
  1157.     case T_FAXNUMBER:
  1158.     case T_FAXNAME:
  1159.     case T_TSI:
  1160.     case T_ECMTYPE:
  1161. if (opt_CRLF()) {
  1162.     replyJobParamValue(*curJob, 213, t);
  1163.     return (true);
  1164. } else if (SPACE() && multi_STRING(s) && CRLF() &&
  1165.   setJobParameter(*curJob, t, s)) {
  1166.     reply(213, "%s set to "%s".", parmToken(t), (const char*) s);
  1167.     return (true);
  1168. }
  1169. break;
  1170.     case T_USE_ECM:
  1171.     case T_USE_TAGLINE:
  1172.     case T_USE_CONTCOVER:
  1173.     case T_SERVERDOCOVER:
  1174.     case T_IGNOREMODEMBUSY:
  1175.     case T_USE_XVRES:
  1176. if (opt_CRLF()) {
  1177.     replyJobParamValue(*curJob, 213, t);
  1178.     return (true);
  1179. } else if (boolean_param(b) &&
  1180.   setJobParameter(*curJob, t, b)) {
  1181.     reply(213, "%s set to %s.", parmToken(t), b ? "YES" : "NO");
  1182.     return (true);
  1183. }
  1184. break;
  1185.     case T_CHOPTHRESH:
  1186. if (opt_CRLF()) {
  1187.     replyJobParamValue(*curJob, 213, t);
  1188.     return (true);
  1189. } else if (string_param(s, "floating point number") &&
  1190.   setJobParameter(*curJob, t, (float) atof(s))) {
  1191.     reply(213, "%s set to %g.", parmToken(t), (float) atof(s));
  1192.     return (true);
  1193. }
  1194. break;
  1195.      case T_COVER: // specify/query cover page document
  1196. if (opt_CRLF()) {
  1197.     replyJobParamValue(*curJob, 213, t);
  1198.     return (true);
  1199. } else if (pathname_param(s)) {
  1200.     addCoverDocument(*curJob, s);
  1201.     return (true);
  1202. }
  1203. break;
  1204.     case T_DOCUMENT: // specify/query normal document
  1205. if (opt_CRLF()) {
  1206.     replyJobParamValue(*curJob, 213, t);
  1207.     return (true);
  1208. } else if (pathname_param(s)) {
  1209.     addDocument(*curJob, s);
  1210.     return (true);
  1211. }
  1212. break;
  1213.     case T_POLL: // specify/query poll operation
  1214. if (opt_CRLF()) {
  1215.     replyJobParamValue(*curJob, 213, t);
  1216.     return (true);
  1217. } else if (SPACE() && STRING(s, "polling selector")) {
  1218.     fxStr pwd;
  1219.     if (opt_CRLF()) {
  1220. addPollOp(*curJob, s, ""); // sep but no pwd
  1221. return (true);
  1222.     } else if (SPACE() && pwd_param(pwd) && CRLF()) {
  1223. addPollOp(*curJob, s, pwd); // sep & pwd
  1224. return (true);
  1225.     }
  1226. }
  1227. break;
  1228.     case T_HELP: // return help
  1229. if (opt_CRLF()) {
  1230.     helpCmd(parmtab, (char*) NULL);
  1231.     return (true);
  1232. } else if (string_param(s, "parameter name")) {
  1233.     s.raisecase();
  1234.     logcmd(T_JPARM, "HELP %s", (const char*) s);
  1235.     helpCmd(parmtab, s);
  1236.     return (true);
  1237. }
  1238. break;
  1239.     default:
  1240. break;
  1241.     }
  1242.     return (false);
  1243. }
  1245. /*
  1246.  * Collect a password.
  1247.  */
  1248. bool
  1249. HylaFAXServer::multi_string_param(fxStr& s, const char* what)
  1250. {
  1251.     return SPACE() && multi_STRING(s, what) && CRLF();
  1252. }
  1254. /*
  1255.  * Collect a single string parameter.
  1256.  */
  1257. bool
  1258. HylaFAXServer::string_param(fxStr& s, const char* what)
  1259. {
  1260.     return SPACE() && STRING(s, what) && CRLF();
  1261. }
  1263. /*
  1264.  * Collect a single number parameter.
  1265.  */
  1266. bool
  1267. HylaFAXServer::number_param(long& n)
  1268. {
  1269.     return SPACE() && NUMBER(n) && CRLF();
  1270. }
  1272. /*
  1273.  * Collect a single boolean parameter.
  1274.  */
  1275. bool
  1276. HylaFAXServer::boolean_param(bool& b)
  1277. {
  1278.     return SPACE() && BOOLEAN(b) && CRLF();
  1279. }
  1281. /*
  1282.  * Collect a single time parameter.
  1283.  */
  1284. bool
  1285. HylaFAXServer::timespec_param(int ndigits, time_t& t)
  1286. {
  1287.     return SPACE() && TIMESPEC(ndigits, t) && CRLF();
  1288. }
  1290. /*
  1291.  * File manipulation command.
  1292.  */
  1293. bool
  1294. HylaFAXServer::pathname_param(fxStr& s)
  1295. {
  1296.     return SPACE() && pathname(s) && CRLF();
  1297. }
  1299. /*
  1300.  * Job control commands.
  1301.  */
  1302. bool
  1303. HylaFAXServer::job_param(fxStr& jid)
  1304. {
  1305.     if (opt_CRLF()) {
  1306. jid = curJob->jobid;
  1307. return (true);
  1308.     } else if (SPACE() && STRING(jid, "job identifer") && CRLF()) {
  1309. jid.lowercase();
  1310. return (true);
  1311.     }
  1312.     return (false);
  1313. }
  1315. /*
  1316.  * Job group control commands.
  1317.  */
  1318. bool
  1319. HylaFAXServer::jgrp_param(fxStr& jgid)
  1320. {
  1321.     if (opt_CRLF()) {
  1322. jgid = curJob->groupid;
  1323. return (true);
  1324.     } else if (SPACE() && STRING(jgid, "job group identifier") && CRLF()) {
  1325. jgid.lowercase();
  1326. return (true);
  1327.     }
  1328.     return (false);
  1329. }
  1331. bool
  1332. HylaFAXServer::pwd_param(fxStr& s)
  1333. {
  1334.     return STRING(s, "polling password");
  1335. }
  1337. bool
  1338. HylaFAXServer::pathname(fxStr& s)
  1339. {
  1340.     return STRING(s, "pathname");
  1341. }
  1343. bool
  1344. HylaFAXServer::TIMESPEC(u_int len, time_t& result)
  1345. {
  1346.     if (getToken(T_STRING, "time specification")) {
  1347. if (tokenBody.length() == len) {
  1348.     if (checkNUMBER(tokenBody)) {
  1349. const char* cp = tokenBody;
  1350. if (len == 12) { // YYYYMMDDHHMM
  1351.     struct tm tm;
  1352.     tm.tm_sec  = 0;
  1353.     tm.tm_min  = twodigits(cp+10, 60);
  1354.     tm.tm_hour = twodigits(cp+8, 24);
  1355.     tm.tm_mday = twodigits(cp+6, 32);
  1356.     tm.tm_mon  = twodigits(cp+4, 13) - 1;
  1357.     tm.tm_year = fourdigits(cp+0) - 1900;
  1358.     tm.tm_isdst = 0; // client gives UTC which never has DST
  1359.     /*
  1360.      * Client specifies time relative to GMT
  1361.      * and mktime returns locally adjusted
  1362.      * time so we need to adjust the result
  1363.      * here to get things in the right timezone.
  1364.      */
  1365.     result = mktime(&tm) - gmtoff;
  1366. } else if (len == 6) { // DDHHMM
  1367.     result = 24*60*60*twodigits(cp, 100)
  1368.    +    60*60*twodigits(cp+2, 24)
  1369.    +       60*twodigits(cp+4, 60);
  1370. } else { // MMSS
  1371.     result = 60*twodigits(cp, 60)
  1372.    +    twodigits(cp+2, 60);
  1373. }
  1374. return (true);
  1375.     }
  1376. } else
  1377.     syntaxError(fxStr::format(
  1378. "bad time specification (expecting %d digits)", len));
  1379.     }
  1380.     return (false);
  1381. }
  1383. bool
  1384. HylaFAXServer::BOOLEAN(bool& b)
  1385. {
  1386.     if (getToken(T_STRING, "boolean")) {
  1387. tokenBody.raisecase();
  1388. if (tokenBody == "YES") {
  1389.     b = true;
  1390.     return (true);
  1391. } else if (tokenBody == "NO") {
  1392.     b = false;
  1393.     return (true);
  1394. } else
  1395.     syntaxError("invalid boolean value, use YES or NO");
  1396.     }
  1397.     return (false);
  1398. }
  1400. bool
  1401. HylaFAXServer::checkToken(Token wanted)
  1402. {
  1403.     Token t = nextToken();
  1404.     if (t != wanted) {
  1405. pushToken(t);
  1406. return (false);
  1407.     } else
  1408. return (true);
  1409. }
  1411. bool
  1412. HylaFAXServer::getToken(Token wanted, const char* expected)
  1413. {
  1414.     Token t = nextToken();
  1415.     if (t != wanted) {
  1416. if (t == T_LEXERR)
  1417.     syntaxError("unmatched quote mark");
  1418. else
  1419.     syntaxError(fxStr::format("expecting %s", expected));
  1420. return (false);
  1421.     } else
  1422. return (true);
  1423. }
  1425. bool HylaFAXServer::SPACE() { return getToken(T_SP, "<SP>"); }
  1426. bool HylaFAXServer::COMMA() { return getToken(T_COMMA, "",""); }
  1427. bool HylaFAXServer::CRLF() { return getToken(T_CRLF, "<CRLF>"); }
  1428. bool HylaFAXServer::opt_CRLF() { return checkToken(T_CRLF); }
  1430. bool
  1431. HylaFAXServer::opt_STRING(fxStr& s)
  1432. {
  1433.     if (checkToken(T_STRING)) {
  1434. s = tokenBody;
  1435. return (true);
  1436.     } else
  1437. return (false);
  1438. }
  1439. bool
  1440. HylaFAXServer::STRING(fxStr& s, const char* what)
  1441. {
  1442.     if (getToken(T_STRING, what != NULL ? what : "<STRING>")) {
  1443. s = tokenBody;
  1444. return (true);
  1445.     } else
  1446. return (false);
  1447. }
  1448. bool
  1449. HylaFAXServer::multi_STRING(fxStr& s, const char* what)
  1450. {
  1451.     if (!STRING(s, what))
  1452. return (false);
  1453.     for (;;) {
  1454. switch (nextToken()) {
  1455. case T_CRLF:
  1456.     pushToken(T_CRLF);
  1457.     return (true);
  1458. case T_COMMA:
  1459.     s.append(',');
  1460.     break;
  1461. case T_STRING:
  1462.     s.append(tokenBody);
  1463.     break;
  1464. case T_SP:
  1465.     s.append(' ');
  1466.     break;
  1467. case T_LEXERR:
  1468.     syntaxError("unmatched quote mark");
  1469.     return (false);
  1470. default:
  1471.     break;
  1472. }
  1473.     }
  1474. }
  1476. bool
  1477. HylaFAXServer::checkNUMBER(const char* cp)
  1478. {
  1479.     if (cp[0] == '-' || cp[0] == '+')
  1480. cp++;
  1481.     for (; *cp; cp++)
  1482. if (!isdigit(*cp)) {
  1483.     syntaxError("invalid number");
  1484.     return (false);
  1485. }
  1486.     return (true);
  1487. }
  1489. bool
  1490. HylaFAXServer::NUMBER(long& n)
  1491. {
  1492.     if (!getToken(T_STRING, "decimal number")) {
  1493. return (false);
  1494.     } else if (!checkNUMBER(tokenBody)) {
  1495. return (false);
  1496.     } else {
  1497. n = strtol(tokenBody, NULL, 0);
  1498. return (true);
  1499.     }
  1500. }
  1502. void
  1503. HylaFAXServer::syntaxError(const char* msg)
  1504. {
  1505.     const char* cp = strchr(cbuf, '');
  1506.     if (cp[-1] == 'n')
  1507. cp--;
  1508.     reply(500, "'%.*s': Syntax error, %s.", cp-cbuf, cbuf, msg);
  1509. }
  1511. /*
  1512.  * Lexical Scanner.
  1513.  */
  1515. /*
  1516.  * Return the next byte of data from the control channel.
  1517.  * If no data is available, either wait for new data to
  1518.  * be received or return EOF.
  1519.  */
  1520. int
  1521. HylaFAXServer::getChar(bool waitForInput)
  1522. {
  1523.     if (recvCC <= 0) {
  1524. // enable non-blocking i/o on control channel
  1525. (void) fcntl(STDIN_FILENO, F_SETFL, ctrlFlags | O_NONBLOCK);
  1526. again:
  1527. do {
  1528.     recvCC = Sys::read(STDIN_FILENO, recvBuf, sizeof (recvBuf));
  1529. } while (recvCC < 0 && errno == EINTR);
  1530. if (recvCC < 0 && errno == EWOULDBLOCK && waitForInput) {
  1531.     Dispatcher& disp = Dispatcher::instance();
  1532.     disp.startTimer(idleTimeout, 0, this);
  1533.     for (state |= S_WAITDATA; IS(WAITDATA); disp.dispatch())
  1534. ;
  1535.     disp.stopTimer(this);
  1536.     goto again;
  1537. }
  1538. (void) fcntl(STDIN_FILENO, F_SETFL, ctrlFlags);
  1539. if (recvCC <= 0) {
  1540.     if (recvCC == 0) { // no more input coming, remove handler
  1541. Dispatcher::instance().unlink(STDIN_FILENO);
  1542. dologout(0); // XXX what about server interactions???
  1543.     }
  1544.     return (EOF);
  1545. }
  1546. recvNext = 0;
  1547.     }
  1548.     recvCC--;
  1549.     return recvBuf[recvNext++] & 0377;
  1550. }
  1552. /*
  1553.  * Push back control channel data.
  1554.  */
  1555. void
  1556. HylaFAXServer::pushCmdData(const char* data, int n)
  1557. {
  1558.     if ((unsigned) recvNext + n > sizeof (recvBuf)) {
  1559. logError("No space to push back urgent data "%.*s"", n, data);
  1560. return;
  1561.     }
  1562.     if (recvNext < n) { // not enough space, copy existing data
  1563. memmove(&recvBuf[n], &recvBuf[recvNext], recvCC);
  1564. recvNext = 0;
  1565.     } else // space available, just adjust recvNext
  1566. recvNext -= n;
  1567.     memcpy(&recvBuf[recvNext], data, n);
  1568.     recvCC += n;
  1569. }
  1571. /*
  1572.  * Return the next line of data received on the control
  1573.  * channel, ignoring any Telnet protocol command sequences.
  1574.  */
  1575. bool
  1576. HylaFAXServer::getCmdLine(char* s, int n, bool waitForInput)
  1577. {
  1578.     char* cp = s;
  1579.     cpos = 0;
  1580.     while (n > 1) {
  1581. int c = getChar(cp != s || waitForInput);
  1582. if (c == EOF)
  1583.     return (false);
  1584. if (c == IAC) { // telnet protocol command
  1585.     c = getChar(true);
  1586.     if (c == EOF)
  1587. return (false);
  1588.     switch (c&0377) {
  1589.     case WILL:
  1590.     case WONT:
  1591. c = getChar(true); // telnet option
  1592. if (c == EOF)
  1593.     return (false);
  1594. printf("%c%c%c", IAC, DONT, c&0377);
  1595. (void) fflush(stdout);
  1596. continue;
  1597.     case DO:
  1598.     case DONT:
  1599. c = getChar(true); // telnet option
  1600. if (c == EOF)
  1601.     return (false);
  1602. printf("%c%c%c", IAC, WONT, c&0377);
  1603. (void) fflush(stdout);
  1604. continue;
  1605.     case IAC: // <IAC><IAC> -> <IAC>
  1606. break;
  1607.     default:    // ignore command
  1608. continue;
  1609.     }
  1610. }
  1611. if (c == 'n') {
  1612.     // convert rn -> n
  1613.     if (cp > s && cp[-1] == 'r')
  1614. cp[-1] = 'n';
  1615.     else
  1616. *cp++ = 'n', n--;
  1617.     break;
  1618. }
  1619. *cp++ = c, n--;
  1620.     }
  1621.     *cp = '';
  1622.     if (TRACE(PROTOCOL))
  1623.         logDebug("command: %s", s);
  1624.     return (true);
  1625. }
  1627. void
  1628. HylaFAXServer::timerExpired(long, long)
  1629. {
  1630.     reply(421,
  1631.       "Timeout (%d seconds): closing control connection.", idleTimeout);
  1632.     if (TRACE(SERVER)) {
  1633. time_t now = Sys::now();
  1634. logInfo("User %s timed out after %d seconds at %.24s"
  1635.     , IS(LOGGEDIN) ? (const char*) the_user : "(noone)"
  1636.     , idleTimeout
  1637.     , asctime(cvtTime(now))
  1638. );
  1639.     }
  1640.     dologout(1);
  1641. }
  1643. Token
  1644. HylaFAXServer::nextToken(void)
  1645. {
  1646.     if (pushedToken != T_NIL) {
  1647. Token t = pushedToken;
  1648. pushedToken = T_NIL;
  1649. return (t);
  1650.     }
  1651.     switch (cbuf[cpos]) {
  1652.     case ' ':
  1653. while (cbuf[++cpos] == ' ') // compress multiple spaces
  1654.     ;
  1655. return (T_SP);
  1656.     case 'n':
  1657. cpos++;
  1658. return (T_CRLF);
  1659.     case ',':
  1660. cpos++;
  1661. return (T_COMMA);
  1662.     case '"':
  1663. /*
  1664.  * Parse quoted string and deal with  escapes.
  1665.  */
  1666. tokenBody.resize(0);
  1667. for (;;) {
  1668.     int c = cbuf[++cpos];
  1669.     if (c == '"') {
  1670. cpos++;
  1671. return (T_STRING);
  1672.     }
  1673.     if (c == 'n') // unmatched quote mark
  1674. return (T_LEXERR);
  1675.     if (c == '\') { //  escape handling
  1676. c = cbuf[++cpos];
  1677. if (isdigit(c)) { // nnn octal escape
  1678.     int v = c - '0';
  1679.     if (isdigit(c = cbuf[cpos+1])) {
  1680. cpos++, v = (v << 3) + (c - '0');
  1681. if (isdigit(c = cbuf[cpos+1]))
  1682.     cpos++, v = (v << 3) + (c - '0');
  1683.     }
  1684.     c = v;
  1685. }
  1686.     }
  1687.     tokenBody.append(c);
  1688. }
  1689. /*NOTREACHED*/
  1690.     }
  1691.     int base = cpos;
  1692.     do {
  1693. cpos++;
  1694.     } while (cbuf[cpos] != ' ' && cbuf[cpos] != 'n' && cbuf[cpos] != ',');
  1695.     tokenBody = fxStr(&cbuf[base], cpos - base);
  1696.     return (T_STRING);
  1697. }
  1699. void
  1700. HylaFAXServer::helpCmd(const tab* ctab, const char* s)
  1701. {
  1702.     const char* type;
  1703.     u_int NCMDS;
  1704.     if (ctab == sitetab) {
  1705.         type = "SITE ";
  1706. NCMDS = N(sitetab);
  1707.     } else if (ctab == parmtab) {
  1708. type = "JPARM ";
  1709. NCMDS = N(parmtab);
  1710.     } else {
  1711.         type = "";
  1712. NCMDS = N(cmdtab);
  1713.     }
  1714.     int width = 0;
  1715.     const tab* c = ctab;
  1716.     for (u_int n = NCMDS; n != 0; c++, n--) {
  1717.         int len = strlen(c->name);
  1718.         if (len > width)
  1719.             width = len;
  1720.     }
  1721.     width = (width + 8) &~ 7;
  1722.     if (s == NULL) {
  1723.         lreply(214, "The following %scommands are recognized %s.",
  1724.             type, "(* =>'s unimplemented)");
  1725.         int columns = 76 / width;
  1726.         if (columns == 0)
  1727.             columns = 1;
  1728.         int lines = (NCMDS + columns - 1) / columns;
  1729.         for (int i = 0; i < lines; i++) {
  1730.             printf("   ");
  1731.             for (int j = 0; j < columns; j++) {
  1732.                 c = &ctab[j*lines + i];
  1733.                 printf("%s%c", c->name, !c->implemented ? '*' : ' ');
  1734.                 if (c + lines >= &ctab[NCMDS])
  1735.                     break;
  1736.                 int w = strlen(c->name) + 1;
  1737.                 while (w < width) {
  1738.                     putchar(' ');
  1739.                     w++;
  1740.                 }
  1741.             }
  1742.             printf("rn");
  1743.         }
  1744.         (void) fflush(stdout);
  1745.         reply(214, "Direct comments to %s.", (const char*) faxContact);
  1746.         return;
  1747.     }
  1748.     c = lookup(ctab, NCMDS, s);
  1749.     if (c == NULL) {
  1750.         reply(502, "Unknown command %s.", s);
  1751.         return;
  1752.     }
  1753.     if (c->implemented)
  1754.         reply(214, "Syntax: %s%s %s", type, c->name, c->help);
  1755.     else
  1756.         reply(214, "%s%-*st%s; unimplemented.", type, width, c->name, c->help);
  1757. }
  1759. void
  1760. HylaFAXServer::logcmd(Token t, const char* fmt ...)
  1761. {
  1762.     if (TRACE(PROTOCOL)) {
  1763. const char* name = cmdToken(t);
  1764. if (!name)
  1765.     name = siteToken(t);
  1766. if (!name)
  1767.     name = "???";
  1768. if (fmt != NULL) {
  1769.     va_list ap;
  1770.     va_start(ap, fmt);
  1771.     vlogInfo(fxStr::format("%s %s", name, fmt), ap);
  1772.     va_end(ap);
  1773. } else
  1774.     logInfo("%s", name);
  1775.     }
  1776. }
  1778. void
  1779. HylaFAXServer::cmdFailure(Token t, const char* why)
  1780. {
  1781.     if (TRACE(SERVER)) {
  1782. const char* cp = cmdToken(t);
  1783. if (!cp)
  1784.     cp = siteToken(t);
  1785. if (cp)
  1786.     logInfo("%s cmd failure - %s", cp, why);
  1787. else
  1788.     logInfo("#%u cmd failure - %s", t, why);
  1789.     }
  1790. }
  1792. bool
  1793. HylaFAXServer::checklogin(Token t)
  1794. {
  1795.     if (!IS(LOGGEDIN)) {
  1796. cmdFailure(t, "not logged in");
  1797. reply(530, "Please login with USER and PASS.");
  1798. return (false);
  1799.     } else
  1800. return (true);
  1801. }
  1803. bool
  1804. HylaFAXServer::checkadmin(Token t)
  1805. {
  1806.     if (checklogin(t)) {
  1807. if (IS(PRIVILEGED))
  1808.     return (true);
  1809. cmdFailure(t, "user is not privileged");
  1810. reply(530, "Please use ADMIN to establish administrative privileges.");
  1811.     }
  1812.     return (false);
  1813. }