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

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

传真(Fax)编程

开发平台：

C/C++

HylaFAXServer.h：源码内容
  1. /* $Id: HylaFAXServer.h,v 1.25 2009/09/29 11:10:13 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.  */
  26. #ifndef _HylaFAXServer_
  27. #define _HylaFAXServer_
  29. #include "FaxConfig.h"
  30. #include "IOHandler.h"
  31. #include "Dictionary.h"
  32. #include "StrArray.h"
  33. #include "FaxRequest.h"
  34. #include "FaxRecvInfo.h"
  35. #include "manifest.h"
  36. #include "FileCache.h"
  37. #include "Trace.h"
  38. #include "Trigger.h"
  39. #include "SystemLog.h"
  41. #include "config.h"
  43. #ifdef HAVE_PAM
  44. extern "C" {
  45. #include <security/pam_appl.h>
  46. #include <grp.h>
  47. }
  48. #endif // HAVE_PAM
  50. #ifdef HAVE_LDAP
  51. #include <ldap.h>
  52. #include <string.h>
  53. #include <stdlib.h>
  54. #include <sys/time.h>
  55. #include <lber.h>
  56. #endif // HAVE_LDAP
  58. #include <sys/types.h>
  59. #include <sys/socket.h>
  60. #include <dirent.h>
  62. #include <setjmp.h>
  63. #include <errno.h>
  65. /*
  66.  * In-memory copy of a job description file.
  67.  */
  68. struct Job : public FaxRequest {
  69.     time_t lastmod; // last file modify time, for updates
  70.     bool queued; // for SNPP
  72.     Job(const fxStr& qf, int fd = -1);
  73.     ~Job();
  75.     bool checkDocument(const char* pathname);
  76. };
  77. fxDECLARE_StrKeyDictionary(JobDict, Job*)
  79. /*
  80.  * Received facsimile information.
  81.  */
  82. struct RecvInfo : public FaxRecvInfo {
  83.     bool beingReceived; // currently being received
  84.     time_t recvTime; // time receive operation started
  86.     RecvInfo();
  87.     RecvInfo(const char* qfile);
  88.     ~RecvInfo();
  89. };
  90. fxDECLARE_StrKeyDictionary(RecvInfoDict, RecvInfo*)
  92. #define HAVE_PSLEVEL2   false
  93.   
  94. static struct {
  95.     const char* name; // protocol token name
  96.     bool        supported; // true if format is supported
  97.     const char* suffix; // file suffix
  98.     FaxSendOp op; // associated FaxSendOp value
  99.     const char* help; // help string for HELP FORM command
  100. } formats[] = {
  101. { "TIFF", true,          "tif", FaxRequest::send_tiff, "Tagged Image File Format, Class F only" },
  102. { "PS",   true,          "ps",  FaxRequest::send_postscript, "Adobe PostScript" },
  103. { "PS2",  HAVE_PSLEVEL2, "ps",  FaxRequest::send_postscript, "Adobe PostScript Level II" },
  104. { "PCL",  true,          "pcl", FaxRequest::send_pcl, "HP Printer Control Language (PCL)"},
  105. { "PDF",  true,          "pdf", FaxRequest::send_pdf, "Adobe Portable Document Format" },
  106. };
  108. #define N(a)    (sizeof (a) / sizeof (a[0]))
  110. #ifdef T_USER
  111. #undef T_USER // XXX FreeBSD defines this
  112. #endif
  114. /*
  115.  * Parser tokens; also used to identify protocol commands/operations.
  116.  */
  117. enum Token {
  118.     /*
  119.      * Syntactic items.
  120.      */
  121.     T_SP, T_CRLF, T_COMMA, T_STRING, T_NUMBER,
  122.     T_NIL, T_LEXERR,
  123.     /*
  124.      * Commands.
  125.      */
  126.     T_ABOR,  T_ACCT, T_ADDMODEM, T_ADDUSER, T_ADMIN,
  127.     T_ALLO,  T_ANSWER, T_APPE, T_CHMOD, T_CHOWN,
  128.     T_CONFIG,  T_CWD,  T_CDUP, T_DELE, T_DELUSER,
  129.     T_DELMODEM,  T_DISABLE, T_ENABLE, T_EPSV, T_EPRT, T_FILEFMT, T_FORM,
  130.     T_HELP,  T_IDLE, T_LOCKWAIT, T_JDELE, T_JGDELE, T_JGINTR,
  131.     T_JGKILL,  T_JGNEW, T_JGPARM, T_JGREST, T_JGRP,
  132.     T_JGSUB,  T_JGSUSP, T_JGWAIT, T_JINTR, T_JKILL,
  133.     T_JNEW,  T_JOB, T_JOBFMT, T_JPARM, T_JREST,
  134.     T_JSUB,  T_JSUSP, T_JWAIT, T_LIST,   T_MDTM,
  135.     T_MODE,  T_MODEMFMT, T_NLST, T_NOOP, T_PASS,
  136.     T_PASV,  T_PORT, T_PWD, T_QUIT, T_RCVFMT,
  137.     T_REIN,  T_REST, T_RETP, T_RETR, T_RNFR,
  138.     T_RNTO,  T_SHUT, T_SITE, T_SIZE, T_STAT,
  139.     T_STOR,  T_STOT, T_STOU, T_STRU, T_SYST,
  140.     T_TRIGGER,  T_TYPE, T_TZONE, T_USER, T_VRFY,
  141.     /*
  142.      * Job state parameters.
  143.      */
  144.     T_ACCTINFO,  T_BEGBR, T_BEGST, T_CHOPTHRESH, T_CLIENT,
  145.     T_COMMENTS,  T_COMMID, T_COVER, T_DATAFORMAT, T_DIALSTRING,
  146.     T_DOCUMENT,  T_DONEOP, T_EXTERNAL, T_FAXNUMBER, T_FAXNAME, T_FROM_COMPANY, T_FROM_LOCATION,
  147.     T_FROM_USER, T_FROM_VOICE, T_GROUPID, T_HRES, T_IGNOREMODEMBUSY, T_JOBID,
  148.     T_JOBINFO,  T_JOBTYPE, T_LASTTIME, T_MAXDIALS, T_MAXPAGES,
  149.     T_MAXTRIES,  T_MINBR, T_MODEM, T_NDIALS, T_NOTIFY,
  150.     T_NOTIFYADDR,T_NPAGES, T_NTRIES, T_OWNER, T_PAGECHOP,
  151.     T_PAGELENGTH,T_PAGEWIDTH, T_PASSWD, T_POLL, T_REGARDING,
  152.     T_RETRYTIME, T_SCHEDPRI, T_SENDTIME, T_SKIPPAGES, T_SKIPPEDPAGES, T_STATE, T_STATUS, T_ERRORCODE,
  153.     T_SUBADDR,  T_TAGLINE, T_TIMEOFDAY, T_TOTDIALS, T_TOTPAGES, T_TOTTRIES,
  154.     T_TO_COMPANY,T_TO_LOCATION, T_TO_USER, T_TO_VOICE, T_TSI, T_USE_CONTCOVER, T_NOCOUNTCOVER, T_SERVERDOCOVER,
  155.     T_USE_ECM,  T_ECMTYPE, T_USE_TAGLINE, T_USE_XVRES, T_USRKEY, T_VRES,
  156.     /*
  157.      * SNPP tokens.
  158.      */
  159.     T_2WAY,  T_ACKREAD, T_ALERT, T_CALLERID, T_COVERAGE,
  160.     T_DATA,  T_EXPTAG, T_HOLDUNTIL, T_JQUEUE, T_KTAG,
  161.     T_LEVEL,  T_LOGIN, T_MCRESPONSE, T_MESSAGE, T_MSTATUS,
  162.     T_NOQUEUEING,T_PAGER, T_PING, T_RTYPE, T_SEND,
  163.     T_SUBJECT
  164. };
  166. struct tab { // protocol command table entry
  167.     const char* name;
  168.     Token token;
  169.     bool checklogin; // if true, must be logged in first
  170.     bool implemented; // false if command is not implemented
  171.     const char* help;
  172. };
  174. class SpoolDir;
  175. struct ParamProtection;
  177. struct stat;
  178. typedef struct tiff TIFF;
  179. class JobExt;
  180. class ModemExt;
  181. class ModemConfig;
  182. class IDCache;
  184. extern const char* fmtTime(time_t t);
  186. /*
  187.  * An instance of a fax server process.
  188.  */
  189. class HylaFAXServer : public SystemLog, public FaxConfig, public IOHandler {
  190. public:
  191.     struct stringtag {
  192.         const char*  name;
  193.         fxStr HylaFAXServer::* p;
  194.         const char*  def; // NULL is shorthand for ""
  195.     };
  196.     struct numbertag {
  197.         const char*  name;
  198.         u_int HylaFAXServer::*p;
  199.         u_int  def;
  200.     };
  201.     static int _debugSleep;
  202.     static fxStrArray configOptions; // Pased on the command line
  203. protected:
  204.     u_int state;
  205. #define S_LOGGEDIN 0x0001 // client is logged in
  206. #define S_PRIVILEGED 0x0002 // client has administrative privileges
  207. #define S_LREPLIES 0x0004 // using continuation msgs in replies
  208. #define S_WAITFIFO 0x0008 // waiting on response to FIFO msg
  209. #define S_USEGMT 0x0010 // process times in GMT or local TZ
  210. #define S_WAITPASS 0x0020 // had user command, waiting for passwd
  211. #define S_TRANSFER 0x0040 // actively transferring data
  212. #define S_WAITDATA 0x0080 // scanner is waiting for data
  213. #define S_WAITTRIG 0x0100 // trigger is active
  214. #define S_LOGTRIG 0x0200 // write trigger events to data conn
  215. #define S_CHECKGID 0x0400 // check if file GID is set correctly
  216. #define S_SETGID 0x0800 // must explicitly force GID on files
  217.     u_int tracingLevel; // server tracing control flags
  218.     fxStr logFacility; // name of syslog facility for logging
  219.     fxStr userAccessFile; // user access control file
  220.     fxStr xferfaxLogFile; // log file for data transfers
  221.     fxStr faxContact; // email account for inquiries
  222.     fxStr systemType; // system ID string returned for SYST
  223.     fxStr faxqFIFOName; // faxq FIFO name
  224.     fxStr clientFIFOName; // client FIFO name
  225.     int faxqFd; // faxq FIFO open descriptor
  226.     int clientFd; // client FIFO open descriptor
  227.     fxStr fifoResponse; // response received to FIFO msg
  228.     u_int idleTimeout; // client inactivity timeout
  229.     u_int maxIdleTimeout; // upper bound on idle timeout
  230.     u_int lockTimeout; // qfile lock timeout
  231.     u_int maxLockTimeout; // upper bound on qfile lock timeout
  232.     int data; // current data connection (socket)
  233.     int pdata; // passive mode data connect (socket)
  234.     fxStr hostname; // name of machine server is running on
  235.     fxStr hostaddr; // primary address for hostname
  236.     fxStr remotehost; // name of peer's machine
  237.     fxStr remoteaddr; // address of peer's machine
  238.     fxStr autospout; // text to send with next reply
  239.     fxStr shutdownFile; // file with shutdown information
  240.     fxStr shutdownMsg; // text of shutdown message
  241.     time_t lastModTime; // last mod. time of shutdown file
  242.     time_t lastTime; // time of last shutdown notification
  243.     time_t discTime; // time to disconnect service
  244.     time_t denyTime; // time to deny service
  245.     u_int jobProtection; // Protection to use on Jobs
  246.     u_int recvqProtection; // Protection to use on Recvq
  247.     /*
  248.      * User authentication and login-related state.
  249.      */
  250. #ifdef HAVE_PAM
  251. bool pam_chrooted; // if already chrooted, PAM gets disabled
  252. #endif
  254.     fxStr passWd; // encrypted user password
  255.     fxStr adminWd; // encrypted passwd for admin privileges
  256. #ifdef HAVE_LDAP
  257.     fxStr ldapServerUri; // URL for the LDAP Server
  258.     fxStr ldapBaseDN; // LDAP base DN where user objects are found
  259.     fxStr ldapReqGroup; // LDAP group users need to be members of for
  260. // fax server access
  261.     u_int ldapVersion; // LDAP Protocol Version being used (def. v3)
  262. #endif
  263.     u_int uid; // client's ID
  264.     u_int loginAttempts; // number of failed login attempts
  265.     u_int maxLoginAttempts; // login failures before server exits
  266.     u_int adminAttempts; // number of failed admin attempts
  267.     u_int maxAdminAttempts; // admin failures before server exits
  268.     fxStr the_user; // name of user
  269. fxStr   admingroup; // name of local user group that is allowed
  270. // to administer the fax server
  271.     IDCache* idcache; // fax UID -> name mapping table
  272.     /*
  273.      * File and file-transfer related state.
  274.      */
  275.     off_t restart_point; // file offset for restarting transfers
  276.     jmp_buf urgcatch; // throw location for transfer interrupt
  277.     off_t file_size; // size of file being transferred
  278.     off_t byte_count; // amount of data currently sent
  279.     int xferfaxlog; // open transfer log file
  280.     int mode; // data transfer mode
  281.     int form; // data transfer format
  282.     int type; // data transfer type
  283.     int stru; // file structure
  284.     SpoolDir* cwd; // current working directory
  285.     fxStrArray tempFiles; // files created with STOT
  286.     fxStr fileFormat; // format string for directory listings
  287.     TIFF* cachedTIFF; // cached open TIFF file
  288.     /*
  289.      * Parser-related state.
  290.      */
  291.     Token pushedToken; // lexical token push back
  292.     fxStr tokenBody; // string body of current lexical token
  293.     char cbuf[512]; // current input line
  294.     int cpos; // position in cbuf
  295.     int ctrlFlags; // file descriptor flags for control
  296.     int recvCC; // amount of data remaining in recvBuf
  297.     int recvNext; // next byte for scanner
  298.     char recvBuf[1024]; // input data buffer
  299.     u_int consecutiveBadCmds; // # consecutive invalid control cmds
  300.     u_int maxConsecutiveBadCmds; // max # before forced disconnect
  301.     /*
  302.      * Job-related state.
  303.      */
  304.     Job defJob; // default job state information
  305.     JobDict jobs; // non-default jobs
  306.     Job* curJob; // current job
  307.     fxStr jobFormat; // job status format string
  308.     JobDict blankJobs; // jobs created during this session but not submitted
  309.     /*
  310.      * Receive queue-related state.
  311.      */
  312.     RecvInfoDict recvq; // cache of info about received fax
  313.     fxStr recvFormat; // received fax status format string
  314.     /*
  315.      * Trigger-related state.
  316.      */
  317.     fxStr trigSpec; // specification for active trigger
  318.     u_int tid; // current active trigger ID
  319.     /*
  320.      * Modem-related state.
  321.      */
  322.     fxStr modemFormat; // modem status format string
  324.     static gid_t faxuid; // system gid of fax user = our uid
  325. #if HAS_TM_ZONE
  326.     const char* tzname[2]; // local timezone name
  327. #endif
  328.     time_t gmtoff; // time_t offset btwn GMT and local time
  330.     void userCmd(const char* name); // USER
  331.     void adminCmd(const char* name); // ADMIN
  332.     void passCmd(const char* passwd); // PASS
  333.     void statusCmd(void); // STAT
  335.     void formCmd(const char* name); // FORM
  336.     void formHelpCmd(void); // FORM
  337.     void typeCmd(const char* name); // TYPE
  338.     void modeCmd(const char* name); // MODE
  339.     void struCmd(const char* name); // STRU
  340.     void deleCmd(const char* name); // DELE
  341.     void mdtmCmd(const char* name); // MDTM
  342.     void cwdCmd(const char *path); // CWD
  343.     void pwdCmd(void); // PWD
  344.     void retrieveCmd(const char* name); // RETR
  345.     void retrievePageCmd(const char* name);// RETP
  346.     void listCmd(const char* name); // LIST
  347.     void nlstCmd(const char* name); // NLST
  348.     void storeCmd(const char*, const char*);// STOR+APPE
  349.     void storeUniqueCmd(bool isTemp); // STOU+STOT
  350.     void statFileCmd(const char* name); // STAT
  351.     void chownCmd(const char*, const char*);// CHOWN
  352.     void chmodCmd(const char*, u_int); // CHMOD
  354.     virtual void passiveCmd(void) = 0; // PASV: depends on transport
  355.     virtual void portCmd(Token) = 0; // PORT: depends on transport
  357.     void triggerCmd(const char*, ...); // TRIGGER
  359.     /*
  360.      * Administrative commands (experimental).
  361.      */
  362.     void abortCallCmd(const char*);
  363.     void addUserCmd(const char* spec, const char* pass, const char* apass);
  364.     void delUserCmd(const char* spec);
  365.     void answerCallCmd(const char* modem, const char* how);
  366.     void disableModemCmd(const char* modem, const char* reason);
  367.     void enableModemCmd(const char* mode);
  368.     void shutCmd(const struct tm& when, const char* reason);
  369.     void addModemCmd(const char* modem);
  370.     void delModemCmd(const char* modem);
  371.     void configQueryCmd(const char* where);
  372.     void configCmd(const char* where, const char* info);
  374.     virtual void initServer(void);
  375.     bool readShutdownFile(void);
  376.     bool isShutdown(bool quiet);
  377.     void fatal(const char *fmt, ...);
  378.     void reply(int code, const char* fmt, ...);
  379.     void vreply(int code, const char* fmt, va_list ap);
  380.     void lreply(int code, const char* fmt, ...);
  381.     void vlreply(int code, const char* fmt, va_list ap);
  382.     void perror_reply(int code, const char* string, int errnum);
  383.     void ack(int code, const char*);
  384.     void printTransferStatus(FILE* fd);
  385.     struct tm* cvtTime(const time_t&) const;
  386.     void setFileOwner(const char* filename);
  388.     void loginRefused(const char* why);
  389.     bool pamCheck(const char* user=NULL, const char* pass=NULL);
  390.     bool pamIsAdmin(const char* user=NULL);
  391. #ifdef HAVE_PAM
  392.     void pamEnd(pam_handle_t *pamh, int pamret);
  393. #endif
  394.     bool checkUser(const char*);
  395.     bool checkuser(FILE*, const char *name);
  396.     bool checkuser(const char *name);
  397.     void login(int code);
  398.     void end_login(void);
  399.     virtual void dologout(int status);
  400.     const char* fixPathname(const char* file);
  401.     const char* userName(u_int uid);
  402.     bool userID(const char*, u_int& id);
  403.     void fillIDCache(void);
  404.     bool ldapCheck(const char* user, const char* pass);
  405.     bool cvtPasswd(const char* type, const char* pass, fxStr& result);
  406.     bool findUser(FILE* db, const char* user, u_int& newuid);
  407.     bool addUser(FILE* db, const char* user, u_int uid,
  408. const char* upass, const char* apass);
  409.     bool deleteUser(FILE* db, const char* user);
  411.     /*
  412.      * Configuration file support.
  413.      */
  414.     static stringtag strings[];
  415.     static numbertag numbers[];
  417.     void resetConfig();
  418.     void setupConfig();
  419.     void configError(const char* fmt, ...);
  420.     void configTrace(const char* fmt, ...);
  421.     bool setConfigItem(const char* tag, const char* value);
  423.     bool restartSend(FILE* fd, off_t marker);
  425.     static SpoolDir dirs[];
  427.     bool checkFileRights(int op, const struct stat&);
  429.     void dirSetup(void);
  430.     static SpoolDir* dirLookup(const char* path);
  431.     static SpoolDir* dirLookup(ino_t ino);
  432.     SpoolDir* dirAccess(const char* path);
  433.     SpoolDir* fileAccess(const char* path, int op, struct stat&);
  434.     bool fileVisible(const SpoolDir&, const char*, const struct stat&);
  436.     bool isVisibleRecvQFile(const char*, const struct stat&);
  437.     void listRecvQ(FILE* fd, const SpoolDir& sd, DIR* dir);
  438.     void listRecvQFile(FILE*, const SpoolDir&, const char*, const struct stat&);
  440.     bool isVisibleSendQFile(const char*, const struct stat&);
  441.     void listSendQ(FILE* fd, const SpoolDir& sd, DIR* dir);
  442.     void listSendQFile(FILE*, const SpoolDir&, const char*, const struct stat&);
  443.     void nlstSendQ(FILE* fd, const SpoolDir& sd, DIR* dir);
  444.     void nlstSendQFile(FILE*, const SpoolDir&, const char*, const struct stat&);
  446.     void listStatus(FILE* fd, const SpoolDir& sd, DIR* dir);
  447.     void listStatusFile(FILE*, const SpoolDir&, const char*, const struct stat&);
  448.     void nlstStatus(FILE* fd, const SpoolDir& sd, DIR* dir);
  450.     bool isVisibletrue(const char*, const struct stat&);
  451.     bool isVisibleDocQFile(const char*, const struct stat&);
  452.     bool isVisibleRootFile(const char*, const struct stat&);
  454.     void listDirectory(FILE* fd, const SpoolDir& sd, DIR* dir);
  455.     void listUnixFile(FILE*, const SpoolDir&, const char*, const struct stat&);
  456.     void makeProt(const struct stat& sb, bool withGrp, char prot[10]);
  457.     void Fprintf(FILE*, const char* fmt, const char*, const struct stat&);
  459.     void nlstDirectory(FILE* fd, const SpoolDir& sd, DIR* dir);
  460.     void nlstUnixFile(FILE*, const SpoolDir&, const char*, const struct stat&);
  462.     virtual FILE* openDataConn(const char* mode, int& code) = 0;
  463.     static const char* dataConnMsg(int code);
  464.     virtual void closeDataConn(FILE*);
  466.     bool sendData(FILE* fdin, FILE* fdout);
  467.     bool sendIData(int fdin, int fdout);
  468.     bool sendZData(int fdin, int fdout);
  469.     bool recvData(FILE* instr, FILE* outstr);
  470.     bool recvIData(int fdin, int fdout);
  471.     bool recvZData(int fdin, int fdout);
  473.     TIFF* openTIFF(const char* name);
  474.     bool sendTIFFData(TIFF* tif, FILE* fdout);
  475.     bool sendTIFFHeader(TIFF* tif, int fdout);
  476.     bool sendITIFFData(TIFF* tif, int fdout);
  478.     void logTransfer(const char*, const SpoolDir&, const char*, time_t);
  480.     virtual int parse(void);
  481.     bool cmd(Token t);
  482.     bool site_cmd(Token t);
  483.     bool param_cmd(Token t);
  484.     bool multi_string_param(fxStr&, const char* what = NULL);
  485.     bool string_param(fxStr&, const char* what = NULL);
  486.     bool number_param(long&);
  487.     bool boolean_param(bool&);
  488.     bool file_param(fxStr& pathname);
  489.     bool pwd_param(fxStr& s);
  490.     bool timespec_param(int ndigits, time_t& t);
  491.     bool pathname_param(fxStr& pathname);
  492.     bool job_param(fxStr& jid);
  493.     bool jgrp_param(fxStr& jgid);
  494.     bool pathname(fxStr& s);
  495.     bool CRLF();
  496.     bool SPACE();
  497.     bool COMMA();
  498.     bool TIMESPEC(u_int len, time_t& result);
  499.     bool BOOLEAN(bool& b);
  500.     bool STRING(fxStr& s, const char* what = NULL);
  501.     bool NUMBER(long& n);
  502.     bool checkNUMBER(const char* s);
  503.     bool opt_CRLF();
  504.     bool opt_STRING(fxStr& s);
  505.     bool multi_STRING(fxStr& s, const char* what = NULL);
  506.     static u_int twodigits(const char* cp, u_int range);
  507.     static u_int fourdigits(const char* cp);
  508.     virtual void syntaxError(const char* msg);
  510.     virtual void netStatus(FILE*) = 0; // depends on transport
  511.     virtual bool hostPort() = 0; // depends on transport
  513.     int getChar(bool waitForInput);
  514.     void pushCmdData(const char* data, int n);
  515.     bool getCmdLine(char* s, int n, bool waitForInput = false);
  516.     void pushToken(Token t);
  517.     Token nextToken(void);
  518.     bool checkToken(Token);
  519.     bool getToken(Token, const char*);
  520.     void helpCmd(const tab* ctab, const char* s);
  521.     void logcmd(Token t, const char* fmt = NULL, ...);
  522.     void cmdFailure(Token t, const char* why);
  523.     bool checklogin(Token);
  524.     bool checkadmin(Token);
  526.     static const char* version;
  528.     virtual const char* cmdToken(Token t);
  529.     virtual const char* siteToken(Token t);
  530.     static const char* parmToken(Token t);
  532.     bool initClientFIFO(fxStr& emsg);
  533.     int FIFOInput(int fd);
  534.     void FIFOMessage(const char* cp, u_int len);
  535.     bool sendModem(const char* modem, fxStr& emsg, const char* fmt ...);
  536.     bool sendQueuerMsg(fxStr& emsg, const fxStr& msg);
  537.     bool sendQueuer(fxStr& emsg, const char* fmt ...);
  538.     bool sendQueuerACK(fxStr& emsg, const char* fmt, ...);
  539.     bool vsendQueuerACK(fxStr& emsg, const char* fmt, va_list ap);
  541.     bool newTrigger(fxStr& emsg, const char* fmt, ...);
  542.     bool vnewTrigger(fxStr& emsg, const char* fmt, va_list ap);
  543.     bool loadTrigger(fxStr& emsg);
  544.     bool cancelTrigger(fxStr& emsg);
  545.     void triggerEvent(const TriggerMsgHeader& h, const char* data);
  546.     void logEventMsg(const TriggerMsgHeader&h, fxStr& msg);
  547.     void logJobEventMsg(const TriggerMsgHeader&, const JobExt&);
  548.     void logSendEventMsg(const TriggerMsgHeader&, const JobExt&, const char*);
  549.     void logModemEventMsg(const TriggerMsgHeader&,
  550. const ModemExt&, const char*);
  551.     void logRecvEventMsg(const TriggerMsgHeader&,
  552. const FaxRecvInfo&, const char*);
  554.     virtual void initDefaultJob(void);
  555.     void parmBotch(Token t);
  556.     bool checkAccess(const Job& job, Token t, u_int op);
  557.     bool checkParm(Job&, Token t, u_int op);
  558.     bool checkJobState(Job*);
  559.     void replyJobParamValue(Job&, int code, Token t);
  560.     void replyBoolean(int code, bool b);
  561.     bool setValue(u_short& v, const char* value, const char* what,
  562. const char* valNames[], u_int nValNames);
  563.     void flushPreparedDocuments(Job& job);
  564.     bool setJobParameter(Job&, Token t, const fxStr& value);
  565.     bool setJobParameter(Job&, Token t, u_short value);
  566.     bool setJobParameter(Job&, Token t, time_t value);
  567.     bool setJobParameter(Job&, Token t, bool b);
  568.     bool setJobParameter(Job&, Token t, float value);
  569.     bool docType(const char* docname, FaxSendOp& op);
  570.     bool checkAddDocument(Job&, Token type, const char* docname, FaxSendOp&);
  571.     void addCoverDocument(Job&, const char* docname);
  572.     void addDocument(Job&, const char* docname);
  573.     void addPollOp(Job&, const char* sep, const char* pwd);
  574.     void newJobCmd(void);
  575.     bool newJob(fxStr& emsg);
  576.     Job* findJob(const char* jobid, fxStr& emsg);
  577.     Job* findJobInMemmory(const char* jobid);
  578.     Job* findJobOnDisk(const char* jobid, fxStr& emsg);
  579.     bool updateJobFromDisk(Job& job);
  580.     void replyCurrentJob(const char* leader);
  581.     void setCurrentJob(const char* jobid);
  582.     Job* preJobCmd(const char* op, const char* jobid, fxStr& emsg);
  583.     void operateOnJob(const char* jobid, const char* what, const char* op);
  584.     void deleteJob(const char* jobid);
  585.     void killJob(const char* jobid);
  586.     void replyBadJob(const Job& job, Token t);
  587.     void resetJob(const char* jobid);
  588.     void interruptJob(const char* jobid);
  589.     void suspendJob(const char* jobid);
  590.     void submitJob(const char* jobid);
  591.     void waitForJob(const char* jobid);
  592.     bool updateJobOnDisk(Job& req, fxStr& emsg);
  593.     bool lockJob(Job& job, int how, fxStr& emsg);
  594.     bool lockJob(Job& job, int how);
  595.     void unlockJob(Job& job);
  596.     void purgeJobs(void);
  597.     void jstatCmd(const Job&);
  598.     void jstatLine(Token t, const char* fmt ...);
  600.     const char* compactTime(time_t t);
  601.     void Jprintf(FILE* fd, const char* fmt, const Job& job);
  603.     u_int getJobNumber(fxStr&);
  604.     u_int getDocumentNumber(fxStr&);
  606.     bool getRecvDocStatus(RecvInfo& ri);
  607.     RecvInfo* getRecvInfo(const fxStr& qfile, const struct stat& sb);
  608.     const char* compactRecvTime(time_t t);
  609.     void Rprintf(FILE*, const char*, const RecvInfo&, const struct stat&);
  611.     void getServerStatus(const char* fileName, fxStr& status);
  612.     void Mprintf(FILE*, const char*, const ModemConfig&);
  613. public:
  614.     HylaFAXServer();
  615.     virtual ~HylaFAXServer();
  617.     static void setupPermissions(void);
  618.     static void closeAllBut(int fd);
  619.     static void closeAllDispatched();
  621.     static void sanitize(fxStr& s);
  622.     static void canonModem(fxStr& s);
  623.     static void canonDevID(fxStr& s);
  625.     virtual void open(void);
  626.     virtual void close(void);
  628.     virtual int inputReady(int);
  629.     void timerExpired(long, long);
  630. };
  631. inline void HylaFAXServer::pushToken(Token t) { pushedToken = t; }
  633. /*
  634.  * Directories in the spooling area are treated
  635.  * specially to hide implementation details and
  636.  * privileged information that clients have no
  637.  * business seeing.  Also we implement an access
  638.  * control system that is built on top of the
  639.  * normal UNIX protection mechanisms.
  640.  */
  641. struct SpoolDir {
  642.     const char* pathname;
  643.     bool adminOnly; // accessible by unprivileged clients
  644.     bool storAble; // unprivileged clients may STOR files
  645.     bool deleAble; // unprivileged clients may DELE files
  646.     ino_t ino; // directory inode number
  647.     bool (HylaFAXServer::*isVisibleFile)(const char*, const struct stat&);
  648.     void (HylaFAXServer::*listDirectory)(FILE*, const SpoolDir&, DIR*);
  649.     void (HylaFAXServer::*listFile)(FILE*, const SpoolDir&,
  650.         const char*, const struct stat&);
  651.     void (HylaFAXServer::*nlstDirectory)(FILE*, const SpoolDir&, DIR*);
  652.     void (HylaFAXServer::*nlstFile)(FILE*, const SpoolDir&,
  653.         const char*, const struct stat&);
  654.     void (HylaFAXServer::*delFile)(const SpoolDir&, const char*);
  655.     void (HylaFAXServer::*retrFile)(const SpoolDir&, const char*);
  656.     void (HylaFAXServer::*storFile)(const SpoolDir&, const char*);
  657. };
  659. #define IS(x) ((state & (S_##x)) != 0)
  661. #endif /* _HylaFAXServer_ */