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

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

传真(Fax)编程

开发平台：

C/C++

Jobs.c++：源码内容
  1. /* $Id: Jobs.c++,v 1.26 2008/10/12 04:04:28 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. #include "port.h"
  28. #include "config.h"
  29. #include "Sys.h"
  30. #include "HylaFAXServer.h"
  31. #include "Dispatcher.h"
  32. #include "Timeout.h"
  33. #include "class2.h"
  35. #include <sys/file.h>
  36. #include <ctype.h>
  38. /*
  39.  * Job state query and control commands.
  40.  */
  41. Job::Job(const fxStr& qf, int f) : FaxRequest(qf,f)
  42. {
  43.     lastmod = 0;
  44.     queued = false;
  45. }
  46. Job::~Job() {}
  48. /*
  49.  * We need to override the default logic because faxq
  50.  * assumes it's working directory is at the top of the
  51.  * spooling area and we may be elsewhere.  We can also
  52.  * simplify things because we know we're chroot'd to
  53.  * the top of the spooling area--thus we don't need to
  54.  * check for ``..'' and ``/'' being used to reference
  55.  * files outside the spooling area.
  56.  */
  57. bool
  58. Job::checkDocument(const char* pathname)
  59. {
  60.     struct stat sb;
  61.     if (FileCache::lookup(fxStr::format("/%s", pathname), sb))
  62. return (true);
  63.     int fd = Sys::open(pathname, 0);
  64.     if (fd == -1) {
  65. logError("Can not access document file "%s": %s",
  66.     pathname, strerror(errno));
  67. return (false);
  68.     }
  69.     Sys::close(fd);
  70.     logError("Undetermined error with document file "%s"", pathname);
  71.     return (false);
  72. }
  74. fxIMPLEMENT_StrKeyPtrValueDictionary(JobDict, Job*)
  76. /*
  77.  * Job state parameter access controls.
  78.  *
  79.  * There are three levels of access control applied to job state
  80.  * information: administrator, owner, and other.
  81.  * Access is controlled on a read+write basis.  Write accesses
  82.  * can be further restricted to constrain written values to
  83.  * be within a range; this is used to allow users to change
  84.  * parameters within a restricted range (e.g. to up the maximum
  85.  * number of tries but still constrain it to a sane value).
  86.  */
  87. #define A_RUSR 0400 // read permission: owner
  88. #define A_WUSR 0200 // abitrary write permission: owner
  89. #define A_MUSR 0100 // restricted write permission: owner
  90. #define A_RADM 0040 // read permission: administrator
  91. #define A_WADM 0020 // abitrary write permission: administrator
  92. #define A_MADM 0010 // restricted write permission: administrator
  93. #define A_ROTH 0004 // read permission: other
  94. #define A_WOTH 0002 // abitrary write permission: other
  95. #define A_MOTH 0001 // restricted write permission: other
  97. #define A_READ  004
  98. #define A_WRITE  002
  99. #define A_MODIFY 001
  101. #define N(a) (sizeof (a) / sizeof (a[0]))
  103. static const struct {
  104.     Token t;
  105.     u_int protect; // read+write protection
  106. } params[] = {
  107.     { T_BEGBR, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  108.     { T_BEGST, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  109.     { T_CHOPTHRESH, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  110.     { T_CLIENT, A_RUSR|A_RADM|A_WADM|A_ROTH },
  111.     { T_COMMID, A_RUSR|A_RADM|A_ROTH },
  112.     { T_COMMENTS, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  113.     { T_TIMEOFDAY, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  114.     { T_COVER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  115.     { T_DATAFORMAT, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  116.     { T_DIALSTRING, A_RUSR|A_WUSR|A_RADM|A_WADM },
  117.     { T_DOCUMENT, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  118.     { T_DONEOP, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  119.     { T_EXTERNAL, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  120.     { T_FAXNUMBER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  121.     { T_FAXNAME, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  122.     { T_FROM_COMPANY, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  123.     { T_FROM_LOCATION, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  124.     { T_FROM_USER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  125.     { T_FROM_VOICE, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  126.     { T_GROUPID, A_RUSR|A_RADM|A_ROTH },
  127.     { T_IGNOREMODEMBUSY,A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  128.     { T_JOBID, A_RUSR|A_RADM|A_ROTH },
  129.     { T_JOBINFO, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  130.     { T_JOBTYPE, A_RUSR|A_RADM|A_ROTH },
  131.     { T_LASTTIME, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  132.     { T_MAXDIALS, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  133.     { T_MAXPAGES, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  134.     { T_MAXTRIES, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  135.     { T_MINBR, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  136.     { T_MODEM, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  137.     { T_OWNER, A_RUSR|A_RADM|A_WADM|A_ROTH },
  138.     { T_NDIALS, A_RUSR|A_RADM|A_ROTH },
  139.     { T_NOTIFY, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  140.     { T_NOTIFYADDR, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  141.     { T_NPAGES, A_RUSR|A_RADM|A_ROTH },
  142.     { T_NTRIES, A_RUSR|A_RADM|A_ROTH },
  143.     { T_PAGECHOP, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  144.     { T_PAGELENGTH, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  145.     { T_PAGEWIDTH, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  146.     { T_PASSWD, A_RUSR|A_WUSR|A_RADM|A_WADM },
  147.     { T_POLL, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  148.     { T_REGARDING, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  149.     { T_RETRYTIME, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  150.     { T_SCHEDPRI, A_RUSR|A_MUSR|A_RADM|A_WADM|A_ROTH },
  151.     { T_SENDTIME, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  152.     { T_SKIPPAGES, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  153.     { T_SKIPPEDPAGES, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  154.     { T_NOCOUNTCOVER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  155.     { T_STATE, A_RUSR|A_RADM|A_ROTH },
  156.     { T_STATUS, A_RUSR|A_RADM|A_WADM|A_ROTH },
  157.     { T_ERRORCODE, A_RUSR|A_RADM|A_WADM|A_ROTH },
  158.     { T_SERVERDOCOVER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  159.     { T_SUBADDR, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  160.     { T_TAGLINE, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  161.     { T_TOTDIALS, A_RUSR|A_RADM|A_ROTH },
  162.     { T_TOTPAGES, A_RUSR|A_RADM|A_ROTH },
  163.     { T_TOTTRIES, A_RUSR|A_RADM|A_ROTH },
  164.     { T_TO_COMPANY, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  165.     { T_TO_LOCATION, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  166.     { T_TO_USER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  167.     { T_TO_VOICE, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  168.     { T_TSI, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  169.     { T_USE_CONTCOVER, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  170.     { T_USE_ECM, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  171.     { T_ECMTYPE, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  172.     { T_USE_TAGLINE, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  173.     { T_USE_XVRES, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  174.     { T_USRKEY, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  175.     { T_VRES, A_RUSR|A_WUSR|A_RADM|A_WADM|A_ROTH },
  176.     { T_NIL, 0 },
  177. };
  179. /*
  180.  * Check client permission to do the specified operation
  181.  * on the specified job state parameter.  Operation can
  182.  * be a combination of A_READ+A_WRITE+A_MODIFY.  Note that
  183.  * ownership is based on login account and not fax uid;
  184.  * this may need to be rethought.
  185.  */
  186. bool
  187. HylaFAXServer::checkAccess(const Job& job, Token t, u_int op)
  188. {
  189.     u_int m = 0;
  190.     if (t == T_JOB) {
  191.      m = jobProtection;
  192.     } else {
  193. u_int n = N(params)-1;
  194. u_int i = 0;
  195. while (i < n && params[i].t != t)
  196.     i++;
  197. m = params[i].protect;
  198.     }
  199.     if (m&op) // other/public access
  200. return (true);
  201.     if (IS(PRIVILEGED) && ((m>>3)&op)) // administrative access
  202. return (true);
  203.     if (job.owner == the_user && ((m>>6)&op)) // owner access
  204. return (true);
  205.     return (false);
  206. }
  208. static struct {
  209.     Token t;
  210.     fxStr Job::* p;
  211. } strvals[] = {
  212.     { T_JOBTYPE, &Job::jobtype },
  213.     { T_EXTERNAL, &Job::external },
  214.     { T_DIALSTRING, &Job::number },
  215.     { T_NOTIFYADDR, &Job::mailaddr },
  216.     { T_USRKEY, &Job::jobtag },
  217.     { T_MODEM, &Job::modem },
  218.     { T_TO_USER, &Job::receiver },
  219.     { T_TO_COMPANY, &Job::company },
  220.     { T_TO_LOCATION, &Job::location },
  221.     { T_TO_VOICE, &Job::voice },
  222.     { T_FROM_USER, &Job::sender },
  223.     { T_FROM_COMPANY, &Job::fromcompany },
  224.     { T_FROM_LOCATION, &Job::fromlocation },
  225.     { T_FROM_VOICE, &Job::fromvoice },
  226.     { T_PASSWD, &Job::passwd },
  227.     { T_CLIENT, &Job::client },
  228.     { T_FAXNUMBER, &Job::faxnumber },
  229.     { T_FAXNAME, &Job::faxname },
  230.     { T_TSI, &Job::tsi },
  231.     { T_TAGLINE, &Job::tagline },
  232.     { T_SUBADDR, &Job::subaddr },
  233.     { T_GROUPID, &Job::groupid },
  234.     { T_JOBID, &Job::jobid },
  235.     { T_JOBINFO, &Job::jobtag },
  236.     { T_OWNER, &Job::owner },
  237.     { T_STATUS, &Job::notice },
  238.     { T_ERRORCODE, &Job::errorcode },
  239.     { T_DONEOP, &Job::doneop },
  240.     { T_COMMID, &Job::commid },
  241.     { T_REGARDING, &Job::regarding },
  242.     { T_COMMENTS, &Job::comments },
  243.     { T_TIMEOFDAY, &Job::timeofday },
  244. };
  245. static struct {
  246.     Token t;
  247.     u_short Job::* p;
  248. } shortvals[] = {
  249.     { T_TOTPAGES, &Job::totpages },
  250.     { T_NPAGES, &Job::npages },
  251.     { T_SKIPPAGES, &Job::skippages },
  252.     { T_NOCOUNTCOVER, &Job::nocountcover },
  253.     { T_NTRIES, &Job::ntries },
  254.     { T_NDIALS, &Job::ndials },
  255.     { T_TOTDIALS, &Job::totdials },
  256.     { T_MAXDIALS, &Job::maxdials },
  257.     { T_TOTTRIES, &Job::tottries },
  258.     { T_MAXTRIES, &Job::maxtries },
  259.     { T_PAGEWIDTH, &Job::pagewidth },
  260.     { T_PAGELENGTH, &Job::pagelength },
  261.     { T_VRES, &Job::resolution },
  262.     { T_SCHEDPRI, &Job::usrpri },
  263.     { T_MINBR, &Job::minbr },
  264.     { T_BEGBR, &Job::desiredbr },
  265.     { T_BEGST, &Job::desiredst },
  266. };
  267. static struct {
  268.     Token t;
  269.     int Job::* p;
  270. } intvals[] = {
  271.     { T_SKIPPEDPAGES, &Job::skippedpages },
  272. };
  273. static const char* notifyVals[4] = {
  274.     "NONE", // no_notice
  275.     "DONE", // when_done
  276.     "REQUEUE", // when_requeued
  277.     "DONE+REQUEUE" // when_done|when_requeued
  278. };
  279. static const char* chopVals[4] = {
  280.     "DEFAULT", // chop_default
  281.     "NONE", // chop_none
  282.     "ALL", // chop_all
  283.     "LAST" // chop_last
  284. };
  285. static const char* dataVals[] = {
  286.     "G31D", // Group 3, 1-D
  287.     "G32D", // Group 3, 2-D
  288.     "G32DUNC", // Group 3, 2-D (w/ uncompressed)
  289.     "G4" // Group 4
  290. };
  291. static const char* ecmVals[] = {
  292.     "NONE", // 0 = no ECM
  293.     "64BIT", // 64-bit T.30-A ECM
  294.     "256BIT", // 256-bit T.30-A ECM
  295.     "HALFDUPLEX", // Half Duplex T.30-C ECM
  296.     "FULLDUPLEX" // Full Duplex T.30-C ECM
  297. };
  298. static const char* stateVals[] = {
  299.     "UNDEFINED", // undefined state (should never be used)
  300.     "SUSPENDED", // not being scheduled
  301.     "PENDING", // waiting for time to send
  302.     "SLEEPING", // waiting for scheduled timeout
  303.     "BLOCKED", // blocked by concurrent activity
  304.     "READY", // ready to be go, waiting for resources
  305.     "ACTIVE", // actively being processed
  306.     "DONE", // processing completed with success
  307.     "FAILED", // processing completed with failure
  308. };
  309. static const char* docTypeNames[] = {
  310.     "FAX", // send_fax
  311.     "TIFF", // send_tiff
  312.     "TIFF", // send_tiff_saved
  313.     "PDF", // send_pdf
  314.     "PDF", // send_pdf_saved
  315.     "PS", // send_postscript
  316.     "PS", // send_postscript_saved
  317.     "PCL", // send_pcl
  318.     "PCL", // send_pcl_saved
  319.     "DATA", // send_data
  320.     "DATA", // send_data_saved
  321.     "POLL", // send_poll
  322.     "PAGE", // send_page
  323.     "PAGE", // send_page_saved
  324.     "UUCP", // send_uucp
  325.     "UNKNOWN", // send_unknown
  326. };
  328. static const char*
  329. boolString(bool b)
  330. {
  331.     return (b ? "YES" : "NO");
  332. }
  333. void
  334. HylaFAXServer::replyBoolean(int code, bool b)
  335. {
  336.     reply(code, "%s", boolString(b));
  337. }
  339. /*
  340.  * Check that the job's in-memory state is consistent
  341.  * with what is on disk.  If the on-disk state is newer then
  342.  * read it in.  If the job has been removed then remove our
  343.  * reference, reset the current job back to the default job,
  344.  * and send the client an error reply.  This method is used
  345.  * before each place a job's state is access.
  346.  */
  347. bool
  348. HylaFAXServer::checkJobState(Job* job)
  349. {
  350.     /*
  351.      * Verify job is still around (another process has
  352.      * not deleted it) and if the on-disk state has
  353.      * been updated, re-read the job description file.
  354.      */
  355.     struct stat sb;
  356.     if (!FileCache::update("/" | job->qfile, sb)) {
  357. jobs.remove(job->jobid);
  358. if (job == curJob) // make default job current
  359.     curJob = &defJob;
  360. delete job, job = NULL;
  361. return (false);
  362.     }
  363.     if (job->lastmod < sb.st_mtime) {
  364. if (updateJobFromDisk(*job))
  365. job->lastmod = sb.st_mtime;
  366.     }
  367.     return (true);
  368. }
  370. /*
  371.  * Check if it's ok to do the specified operation on the
  372.  * current job's state parameter.  If not, return the appropriate
  373.  * error reply.   We disallow modifications on jobs that
  374.  * do not appear to be suspended since otherwise the mods
  375.  * could be lost (in our case they will be lost due to the
  376.  * way that things work).
  377.  */
  378. bool
  379. HylaFAXServer::checkParm(Job& job, Token t, u_int op)
  380. {
  381.     if (!checkJobState(&job)) { // insure consistent state
  382. reply(500, "Cannot access job state; job deleted by another party.");
  383. return (false);
  384.     } else if (!checkAccess(job, t, op)) {
  385. reply(503, "Permission denied: no %s access to job parameter %s."
  386.     , (op == A_READ ? "read" : "write")
  387.     , parmToken(t)
  388. );
  389. return (false);
  390.     } else if ((op & (A_WRITE|A_MODIFY)) &&
  391.       job.state != FaxRequest::state_suspended && job.jobid != "default") {
  392. reply(503, "Suspend the job with JSUSP first.");
  393. return (false);
  394.     } else
  395. return (true);
  396. }
  398. /*
  399.  * Respond to a job state parameter query.
  400.  */
  401. void
  402. HylaFAXServer::replyJobParamValue(Job& job, int code, Token t)
  403. {
  404.     if (!checkParm(job, t, A_READ))
  405. return;
  406.     u_int i, n;
  407.     switch (t) {
  408.     case T_SENDTIME:
  409. if (job.tts != 0) {
  410.     const struct tm* tm = cvtTime(job.tts);
  411.     // XXX should this include seconds?
  412.     reply(code, "%4d%02d%02d%02d%02d%02d"
  413. , tm->tm_year+1900
  414. , tm->tm_mon+1
  415. , tm->tm_mday
  416. , tm->tm_hour
  417. , tm->tm_min
  418. , tm->tm_sec
  419.     );
  420. } else
  421.     reply(code, "NOW");
  422. return;
  423.     case T_LASTTIME:
  424. time_t tv; tv = job.killtime - job.tts; // XXX for __GNUC__
  425. reply(code, "%02d%02d%02d", tv/(24*60*60), (tv/(60*60))%24, (tv/60)%60);
  426. return;
  427.     case T_RETRYTIME:
  428. reply(code, "%02d%02d", job.retrytime/60, job.retrytime%60);
  429. return;
  430.     case T_STATE:
  431. reply(code, "%s", stateVals[job.state]);
  432. return;
  433.     case T_NOTIFY:
  434. reply(code, "%s", notifyVals[job.notify]);
  435. return;
  436.     case T_PAGECHOP:
  437. reply(code, "%s", chopVals[job.pagechop]);
  438. return;
  439.     case T_CHOPTHRESH:
  440. reply(code, "%g", job.chopthreshold);
  441. return;
  442.     case T_DATAFORMAT:
  443. reply(code, "%s", dataVals[job.desireddf]);
  444. return;
  445.     case T_ECMTYPE:
  446. reply(code, "%s", ecmVals[job.desiredec]);
  447. return;
  448.     case T_USE_ECM:
  449. replyBoolean(code, (job.desiredec != EC_DISABLE ? 1 : 0));
  450. return;
  451.     case T_USE_TAGLINE:
  452. replyBoolean(code, job.desiredtl);
  453. return;
  454.     case T_USE_XVRES:
  455. replyBoolean(code, job.usexvres);
  456. return;
  457.     case T_USE_CONTCOVER:
  458. replyBoolean(code, job.useccover);
  459. return;
  460.     case T_SERVERDOCOVER:
  461. replyBoolean(code, job.serverdocover);
  462. return;
  463.     case T_IGNOREMODEMBUSY:
  464. replyBoolean(code, job.ignoremodembusy);
  465. return;
  466.     case T_DOCUMENT:
  467. for (i = 0, n = job.items.length(); i < n; i++) {
  468.     const FaxItem& fitem = job.items[i];
  469.     // XXX should cover page docs not be shown?
  470.     switch (fitem.op) {
  471.     case FaxRequest::send_pdf:
  472.     case FaxRequest::send_pdf_saved:
  473.     case FaxRequest::send_tiff:
  474.     case FaxRequest::send_tiff_saved:
  475.     case FaxRequest::send_postscript:
  476.     case FaxRequest::send_postscript_saved:
  477.     case FaxRequest::send_pcl:
  478.     case FaxRequest::send_pcl_saved:
  479. lreply(code, "%s %s",
  480.     docTypeNames[fitem.op], (const char*) fitem.item);
  481. break;
  482.     }
  483. }
  484. reply(code, "End of documents.");
  485. return;
  486.     case T_COVER:
  487. for (i = 0, n = job.items.length(); i < n; i++) {
  488.     const FaxItem& fitem = job.items[i];
  489.     if (fitem.item.length() > 7 && fitem.item.tail(6) == ".cover") {
  490. switch (fitem.op) {
  491. case FaxRequest::send_tiff:
  492. case FaxRequest::send_tiff_saved:
  493. case FaxRequest::send_pdf:
  494. case FaxRequest::send_pdf_saved:
  495. case FaxRequest::send_postscript:
  496. case FaxRequest::send_postscript_saved:
  497. case FaxRequest::send_pcl:
  498. case FaxRequest::send_pcl_saved:
  499.     reply(code, "%s %s",
  500. docTypeNames[fitem.op], (const char*) fitem.item);
  501.     return;
  502. }
  503.     }
  504. }
  505. reply(code+1, "No cover page document.");
  506. return;
  507.     case T_POLL:
  508. for (i = 0, n = job.items.length(); i < n; i++) {
  509.     const FaxItem& fitem = job.items[i];
  510.     if (fitem.op == FaxRequest::send_poll)
  511. lreply(code, ""%s" "%s"",
  512.     (const char*) fitem.item, (const char*) fitem.addr);
  513. }
  514. reply(code, "End of polling items.");
  515. return;
  516.     default:
  517. break;
  518.     }
  519.     for (i = 0, n = N(strvals); i < n; i++)
  520. if (strvals[i].t == t) {
  521.     reply(code, "%s", (const char*) (job.*strvals[i].p));
  522.     return;
  523. }
  524.     for (i = 0, n = N(shortvals); i < n; i++)
  525. if (shortvals[i].t == t) {
  526.     reply(code, "%u", job.*shortvals[i].p);
  527.     return;
  528. }
  529.     for (i = 0, n = N(intvals); i < n; i++)
  530. if (intvals[i].t == t) {
  531.     reply(code, "%u", job.*intvals[i].p);
  532.     return;
  533. }
  534.     reply(500, "Botch: no support for querying parameter value.");
  535. }
  537. void
  538. HylaFAXServer::jstatLine(Token t, const char* fmt ...)
  539. {
  540.     printf("    %s: ", parmToken(t));
  541.     va_list ap;
  542.     va_start(ap, fmt);
  543.     vprintf(fmt, ap);
  544.     va_end(ap);
  545.     printf("rn");
  546. }
  548. /*
  549.  * Implement the jparm command that returns the entire
  550.  * job state as a series of parameter: value pairs.
  551.  * This command is mainly intended for debugging and
  552.  * may go away in the final spec (or become a site cmd).
  553.  */
  554. void
  555. HylaFAXServer::jstatCmd(const Job& job)
  556. {
  557.     lreply(217, "Job state: jobid %s groupid %s",
  558. (const char*) job.jobid, (const char*) job.groupid);
  559.     if (checkAccess(job, T_SENDTIME, A_READ)) {
  560. if (job.tts != 0) {
  561.     const struct tm* tm = cvtTime(job.tts);
  562.     // XXX should this include seconds? (useful for debugging)
  563.     jstatLine(T_SENDTIME, "%d%02d%02d%02d%02d%02d"
  564. , tm->tm_year+1900
  565. , tm->tm_mon+1
  566. , tm->tm_mday
  567. , tm->tm_hour
  568. , tm->tm_min
  569. , tm->tm_sec
  570.     );
  571. } else
  572.     jstatLine(T_SENDTIME, "%s", "NOW");
  573.     }
  574.     if (checkAccess(job, T_LASTTIME, A_READ)) {
  575. time_t tv = job.killtime - job.tts;
  576. jstatLine(T_LASTTIME, "%02d%02d%02d",
  577.     tv/(24*60*60), (tv/(60*60))%24, (tv/60)%60);
  578.     }
  579.     if (checkAccess(job, T_RETRYTIME, A_READ))
  580. jstatLine(T_RETRYTIME, "%02d%02d", job.retrytime/60, job.retrytime%60);
  581.     if (checkAccess(job, T_STATE, A_READ))
  582. jstatLine(T_STATE, "%s", stateVals[job.state]);
  583.     if (checkAccess(job, T_NOTIFY, A_READ))
  584. jstatLine(T_NOTIFY, "%s", notifyVals[job.notify]);
  585.     if (checkAccess(job, T_PAGECHOP, A_READ))
  586. jstatLine(T_PAGECHOP, "%s", chopVals[job.pagechop]);
  587.     if (checkAccess(job, T_CHOPTHRESH, A_READ))
  588. jstatLine(T_CHOPTHRESH, "%g", job.chopthreshold);
  589.     if (checkAccess(job, T_DATAFORMAT, A_READ))
  590. jstatLine(T_DATAFORMAT, "%s", dataVals[job.desireddf]);
  591.     if (checkAccess(job, T_ECMTYPE, A_READ))
  592. jstatLine(T_ECMTYPE, "%s", ecmVals[job.desiredec]);
  593.     if (checkAccess(job, T_USE_ECM, A_READ))
  594. jstatLine(T_USE_ECM, "%s", boolString(job.desiredec != EC_DISABLE ? 1 : 0));
  595.     if (checkAccess(job, T_USE_TAGLINE, A_READ))
  596. jstatLine(T_USE_TAGLINE,"%s", boolString(job.desiredtl));
  597.     if (checkAccess(job, T_USE_XVRES, A_READ))
  598. jstatLine(T_USE_XVRES,"%s", boolString(job.usexvres));
  599.     if (checkAccess(job, T_USE_CONTCOVER, A_READ))
  600. jstatLine(T_USE_CONTCOVER,"%s", boolString(job.useccover));
  601.     if (checkAccess(job, T_SERVERDOCOVER, A_READ))
  602. jstatLine(T_SERVERDOCOVER,"%s", boolString(job.serverdocover));
  603.     if (checkAccess(job, T_IGNOREMODEMBUSY, A_READ))
  604. jstatLine(T_IGNOREMODEMBUSY,"%s", boolString(job.ignoremodembusy));
  605.     u_int i, n;
  606.     for (i = 0, n = N(strvals); i < n; i++)
  607. if (checkAccess(job, strvals[i].t, A_READ))
  608.     jstatLine(strvals[i].t, "%s", (const char*) (job.*strvals[i].p));
  609.     for (i = 0, n = N(shortvals); i < n; i++)
  610. if (checkAccess(job, shortvals[i].t, A_READ))
  611.     jstatLine(shortvals[i].t, "%u", job.*shortvals[i].p);
  612.     for (i = 0, n = N(intvals); i < n; i++)
  613. if (checkAccess(job, intvals[i].t, A_READ))
  614.     jstatLine(intvals[i].t, "%u", job.*intvals[i].p);
  615.     /*
  616.      * NB: This assumes access to T_DOCUMENT is sufficient
  617.      *     for access to T_COVER and T_POLL also.
  618.      */
  619.     if (checkAccess(job, T_DOCUMENT, A_READ)) {
  620. for (i = 0, n = job.items.length(); i < n; i++) {
  621.     const FaxItem& fitem = job.items[i];
  622.     switch (fitem.op) {
  623.     case FaxRequest::send_fax:
  624. jstatLine(T_DOCUMENT, "%s %s %u", docTypeNames[fitem.op],
  625.     (const char*) fitem.item, fitem.dirnum);
  626. break;
  627.     case FaxRequest::send_tiff:
  628.     case FaxRequest::send_tiff_saved:
  629.     case FaxRequest::send_pdf:
  630.     case FaxRequest::send_pdf_saved:
  631.     case FaxRequest::send_postscript:
  632.     case FaxRequest::send_postscript_saved:
  633.     case FaxRequest::send_pcl:
  634.     case FaxRequest::send_pcl_saved:
  635.     case FaxRequest::send_data:
  636.     case FaxRequest::send_data_saved:
  637. jstatLine(
  638.     (fitem.item.length() > 7 && fitem.item.tail(6) == ".cover" ?
  639. T_COVER : T_DOCUMENT) 
  640.     , "%s %s"
  641.     , docTypeNames[fitem.op]
  642.     , (const char*) fitem.item
  643. );
  644. break;
  645.     case FaxRequest::send_page:
  646.     case FaxRequest::send_page_saved:
  647. jstatLine(T_DOCUMENT
  648.     , fitem.addr == "" ? "%s "%s"" : "%s "%s" "%s""
  649.     , docTypeNames[fitem.op]
  650.     , (const char*) fitem.item
  651.     , (const char*) fitem.addr
  652. );
  653. break;
  654.     case FaxRequest::send_poll:
  655. jstatLine(T_POLL
  656.     , fitem.addr == "" ? ""%s"" : ""%s" "%s""
  657.     , (const char*) fitem.item
  658.     , (const char*) fitem.addr
  659. );
  660. break;
  661.     }
  662. }
  663.     }
  664.     reply(217, "End of job %s state.", (const char*) job.jobid);
  665. }
  667. /* 
  668.  * Set a job state parameter value from an array of
  669.  * parameter names; the value is the index into the
  670.  * array.  Parameter names are case-insensitive. 
  671.  * Unknown values cause an error reply.  
  672.  */
  673. bool
  674. HylaFAXServer::setValue(u_short& v, const char* value, const char* what,
  675.     const char* valNames[], u_int nValNames)
  676. {
  677.     for (u_int i = 0; i < nValNames; i++)
  678. if (strcasecmp(value, valNames[i]) == 0) {
  679.     v = i;
  680.     return (true);
  681. }
  682.     reply(503, "Unknown %s value %s.", what, value);
  683.     return (false);
  684. }
  686. void
  687. HylaFAXServer::parmBotch(Token t)
  688. {
  689.     reply(503, "Botch, don't know how to set %s parameter.", parmToken(t));
  690. }
  692. /*
  693.  * Discard any prepared documents so that
  694.  * they will be re-prepared with revised
  695.  * parameters.
  696.  */
  697. void
  698. HylaFAXServer::flushPreparedDocuments(Job& job)
  699. {
  700.     u_int j = 0;
  701.     while (j < job.items.length()) {
  702. FaxItem& fitem = job.items[j];
  703. if (fitem.op == FaxRequest::send_fax) {
  704.     // NB: don't waste time requesting ACK
  705.     fxStr emsg;
  706.     sendQueuer(emsg, "U%s", (const char*) fitem.item);
  707.     job.items.remove(j);
  708.     continue;
  709. }
  710. if (fitem.isSavedOp())
  711.     fitem.op--; // assumes order of enum
  712. j++;
  713.     }
  714.     job.pagehandling = ""; // force recalculation
  715. }
  717. /*
  718.  * Set a job state parameter that has a string value.
  719.  */
  720. bool
  721. HylaFAXServer::setJobParameter(Job& job, Token t, const fxStr& value)
  722. {
  723.     if (checkParm(job, t, A_WRITE|A_MODIFY)) {
  724. switch (t) {
  725. case T_NOTIFY:
  726.     return setValue(job.notify, value, parmToken(t),
  727. notifyVals, N(notifyVals));
  728. case T_PAGECHOP:
  729.     if (setValue(job.pagechop, value, parmToken(t),
  730.       chopVals, N(chopVals))) {
  731. job.pagehandling = ""; // force recalculation
  732. return (true);
  733.     } else
  734. return (false);
  735. case T_DATAFORMAT:
  736.     if (setValue(job.desireddf, value, parmToken(t),
  737.       dataVals, N(dataVals))) {
  738. flushPreparedDocuments(job);
  739. return (true);
  740.     } else
  741. return (false);
  742. case T_ECMTYPE:
  743.     if (setValue(job.desiredec, value, parmToken(t),
  744.       ecmVals, N(ecmVals))) {
  745. return (true);
  746.     } else
  747. return (false);
  748. default:
  749.     break;
  750. }
  751. for (u_int i = 0, n = N(strvals); i < n; i++)
  752.     if (strvals[i].t == t) {
  753. job.*strvals[i].p = value;
  754. return (true);
  755.     }
  756. parmBotch(t);
  757.     }
  758.     return (false);
  759. }
  761. /*
  762.  * Set a job state parameter that has a integer value.
  763.  */
  764. bool
  765. HylaFAXServer::setJobParameter(Job& job, Token t, u_short value)
  766. {
  767.     if (checkParm(job, t, A_WRITE|A_MODIFY)) {
  768. for (u_int i = 0, n = N(shortvals); i < n; i++)
  769.     if (shortvals[i].t == t) {
  770. if (job.*shortvals[i].p != value) {
  771.     // XXX constrain values per A_MODIFY
  772.     job.*shortvals[i].p = value; // XXX
  773.     /*
  774.      * Handle parameters with side effects.
  775.      */
  776.     switch (t) {
  777.     case T_PAGEWIDTH:
  778.     case T_PAGELENGTH:
  779.     case T_VRES:
  780.     case T_HRES:
  781. flushPreparedDocuments(job);
  782. break;
  783.     case T_SCHEDPRI:
  784. job.pri = job.usrpri; // reload
  785. break;
  786.     default:
  787. break;
  788.     }
  789. }
  790. return (true);
  791.     }
  792. for (u_int i = 0, n = N(intvals); i < n; i++)
  793.     if (intvals[i].t == t) {
  794. if (job.*intvals[i].p != value) {
  795.     // XXX constrain values per A_MODIFY
  796.     job.*intvals[i].p = value; // XXX
  797. }
  798. return (true);
  799.     }
  800. parmBotch(t);
  801.     }
  802.     return (false);
  803. }
  805. /*
  806.  * Set a job state parameter that has a time value.
  807.  */
  808. bool
  809. HylaFAXServer::setJobParameter(Job& job, Token t, time_t value)
  810. {
  811.     if (checkParm(job, t, A_WRITE|A_MODIFY)) {
  812. time_t now = Sys::now();
  813. switch (t) {
  814. case T_SENDTIME:
  815.     if (value != 0) { // explicit time
  816. /*
  817.  * We don't complain anymore if this value is in the
  818.  * past.  Instead, we verify that the killtime is in
  819.  * the future, ensuring that a window of send-time
  820.  * opportunity still exists.
  821.  */
  822. job.tts = value;
  823.     } else // ``NOW''
  824. job.tts = now;
  825.     return (true);
  826. case T_LASTTIME:
  827.     /*
  828.      * Convert client-specified kill time (as a relative number)
  829.      * to an absolute time.  If the time-to-send has been set,
  830.      * then the killtime is relative to that; otherwise it's
  831.      * made relative to ``now''.  Note that this implies the
  832.      * order of setting SENDTIME and LASTTIME is important; if
  833.      * a client sets LASTTIME before SENDTIME then an unexpected
  834.      * value may be installed for LASTTIME.
  835.      */
  836.     job.killtime = value + (job.tts == 0 ? now : job.tts);
  837.     if (job.killtime < now) {
  838. reply(503, "Bad time to send; time window is entirely in the past.");
  839. return (false);
  840.     }
  841.     return (true);
  842. case T_RETRYTIME:
  843.     job.retrytime = value;
  844.     return (true);
  845. default:
  846.     break;
  847. }
  848. parmBotch(t);
  849.     }
  850.     return (false);
  851. }
  853. /*
  854.  * Set a job state parameter that has a boolean value.
  855.  */
  856. bool
  857. HylaFAXServer::setJobParameter(Job& job, Token t, bool b)
  858. {
  859.     if (checkParm(job, t, A_WRITE|A_MODIFY)) {
  860. switch (t) {
  861. case T_USE_ECM:
  862.     job.desiredec = (b ? (job.desiredec == EC_DISABLE ? EC_ENABLE256 : job.desiredec) : EC_DISABLE);
  863.     return (true);
  864. case T_USE_TAGLINE:
  865.     job.desiredtl = b;
  866.     return (true);
  867. case T_USE_XVRES:
  868.     job.usexvres = b;
  869.     return (true);
  870. case T_USE_CONTCOVER:
  871.     job.useccover = b;
  872.     return (true);
  873. case T_SERVERDOCOVER:
  874.     job.serverdocover = b;
  875.     return (true);
  876. case T_IGNOREMODEMBUSY:
  877.     job.ignoremodembusy = b;
  878.     return (true);
  879. default:
  880.     break;
  881. }
  882. parmBotch(t);
  883.     }
  884.     return (false);
  885. }
  887. /*
  888.  * Set a job state parameter that has a float value.
  889.  */
  890. bool
  891. HylaFAXServer::setJobParameter(Job& job, Token t, float value)
  892. {
  893.     if (checkParm(job, t, A_WRITE|A_MODIFY)) {
  894. switch (t) {
  895. case T_CHOPTHRESH:
  896.     if (job.chopthreshold != value) {
  897. job.chopthreshold = value;
  898. job.pagehandling = ""; // force recalculation
  899.     }
  900.     return (true);
  901. default:
  902.     break;
  903. }
  904. parmBotch(t);
  905.     }
  906.     return (false);
  907. }
  909. /*
  910.  * Initialize the default job state.  We
  911.  * explicitly set string values since this
  912.  * routine may be called for a JREST command
  913.  * to reset job state to the default settings.
  914.  */
  915. void
  916. HylaFAXServer::initDefaultJob(void)
  917. {
  918.     defJob.jobid = "default";
  919.     defJob.owner = the_user;
  920.     defJob.state = FaxRequest::state_undefined;
  921.     defJob.maxdials = FAX_REDIALS;
  922.     defJob.maxtries = FAX_RETRIES;
  923.     defJob.pagewidth = 0;
  924.     defJob.pagelength = 0;
  925.     defJob.resolution = FAX_DEFVRES;
  926.     defJob.usrpri = FAX_DEFPRIORITY;
  927.     defJob.minbr = BR_2400;
  928.     defJob.desiredbr = BR_33600;
  929.     defJob.desiredst = ST_0MS;
  930.     defJob.desiredec = EC_ENABLE256;
  931.     defJob.desireddf = DF_2DMMR;
  932.     defJob.desiredtl = false;
  933.     defJob.usexvres = false;
  934.     defJob.useccover = true;
  935.     defJob.serverdocover= false;
  936.     defJob.ignoremodembusy= false;
  937.     defJob.pagechop = FaxRequest::chop_default;
  938.     defJob.notify = FaxRequest::no_notice;// FAX_DEFNOTIFY
  939.     defJob.chopthreshold= 3.0;
  940.     defJob.tts = 0; // ``NOW''
  941.     defJob.killtime = 3*60*60; // FAX_TIMEOUT
  942.     defJob.retrytime = 0;
  943.     defJob.sender = the_user; // XXX usually incorrect
  944.     defJob.mailaddr = the_user | "@" | remotehost;
  945.     defJob.jobtag = "";
  946.     defJob.number = "";
  947.     defJob.subaddr = "";
  948.     defJob.passwd = "";
  949.     defJob.external = "";
  950.     defJob.modem = MODEM_ANY;
  951.     defJob.faxnumber = "";
  952.     defJob.faxname = "";
  953.     defJob.tsi = "";
  954.     defJob.receiver = "";
  955.     defJob.company = "";
  956.     defJob.location = "";
  957.     defJob.voice = "";
  958.     defJob.fromcompany = "";
  959.     defJob.fromlocation = "";
  960.     defJob.fromvoice = "";
  961.     defJob.regarding = "";
  962.     defJob.comments = "";
  963.     defJob.timeofday = "";
  964.     defJob.errorcode = "";
  965.     defJob.client = remotehost;
  966.     defJob.tagline = "";
  967.     defJob.doneop = "default";
  968.     defJob.nocountcover = 0;
  969.     defJob.skippedpages = 0;
  970.     defJob.skippages = 0;
  971. }
  973. /*
  974.  * JNEW command; create a new job and
  975.  * make it the current job.
  976.  */
  977. void
  978. HylaFAXServer::newJobCmd(void)
  979. {
  980.     fxStr emsg;
  981.     if (newJob(emsg) && updateJobOnDisk(*curJob, emsg)) {
  982. fxStr file("/" | curJob->qfile);
  983. setFileOwner(file); // force ownership
  984. FileCache::chmod(file, jobProtection); // sync cache
  985. curJob->lastmod = Sys::now(); // noone else should update
  986. reply(200, "New job created: jobid: %s groupid: %s.",
  987.     (const char*) curJob->jobid, (const char*) curJob->groupid);
  988. blankJobs[curJob->jobid] = curJob;
  989.     } else
  990. reply(503, "%s.", (const char*) emsg);
  991. }
  993. /*
  994.  * Create a new job, inheriting state from the current
  995.  * job and make the new job be the current job.  Note
  996.  * that the current job must be owned by the client;
  997.  * otherwise people could ``look inside'' other people's
  998.  * jobs by inheriting state--this would permit them to
  999.  * look at privileged information such as calling card
  1000.  * information in dial strings and passwords to be
  1001.  * transmitted with polling items.
  1002.  */
  1003. bool
  1004. HylaFAXServer::newJob(fxStr& emsg)
  1005. {
  1006.     if (!IS(PRIVILEGED) && the_user != curJob->owner) {
  1007. emsg = "Permission denied; cannot inherit from job " | curJob->jobid;
  1008. return (false);
  1009.     }
  1010.     u_int id = getJobNumber(emsg); // allocate unique job ID
  1011.     if (id == (u_int) -1)
  1012. return (false);
  1013.     fxStr jobid = fxStr::format("%u", id);
  1014.     Job* job = new Job(FAX_SENDDIR "/" FAX_QFILEPREF | jobid);
  1015.     job->jobid = jobid;
  1016.     job->groupid = curJob->groupid;
  1017.     if (job->groupid == "")
  1018. job->groupid = jobid;
  1019.     job->owner = the_user;
  1020.     job->state = FaxRequest::state_suspended;
  1021.     job->maxdials = curJob->maxdials;
  1022.     job->maxtries = curJob->maxtries;
  1023.     job->pagewidth = curJob->pagewidth;
  1024.     job->pagelength = curJob->pagelength;
  1025.     job->resolution = curJob->resolution;
  1026.     job->usrpri = curJob->usrpri;
  1027.     job->minbr = curJob->minbr;
  1028.     job->desiredbr = curJob->desiredbr;
  1029.     job->desiredst = curJob->desiredst;
  1030.     job->desiredec = curJob->desiredec;
  1031.     job->desireddf = curJob->desireddf;
  1032.     job->desiredtl = curJob->desiredtl;
  1033.     job->usexvres = curJob->usexvres;
  1034.     job->useccover = curJob->useccover;
  1035.     job->serverdocover = curJob->serverdocover;
  1036.     job->ignoremodembusy = curJob->ignoremodembusy;
  1037.     job->pagechop = curJob->pagechop;
  1038.     job->notify = curJob->notify;
  1039.     job->chopthreshold = curJob->chopthreshold;
  1040.     job->tts = curJob->tts;
  1041.     job->killtime = curJob->killtime;
  1042.     job->retrytime = curJob->retrytime;
  1043.     job->sender = curJob->sender;
  1044.     job->mailaddr = curJob->mailaddr;
  1045.     job->jobtag = curJob->jobtag; // ???
  1046.     job->number = curJob->number;
  1047.     job->external = curJob->external;
  1048.     job->modem = curJob->modem;
  1049.     job->faxnumber = curJob->faxnumber;
  1050.     job->faxname = curJob->faxname;
  1051.     job->tsi = curJob->tsi;
  1052.     job->receiver = curJob->receiver;
  1053.     job->company = curJob->company;
  1054.     job->location = curJob->location;
  1055.     job->voice = curJob->voice;
  1056.     job->fromcompany = curJob->fromcompany;
  1057.     job->fromlocation = curJob->fromlocation;
  1058.     job->fromvoice = curJob->fromvoice;
  1059.     job->regarding = curJob->regarding;
  1060.     job->comments = curJob->comments;
  1061.     job->timeofday = curJob->timeofday;
  1062.     job->jobtype = curJob->jobtype;
  1063.     job->tagline = curJob->tagline;
  1064.     job->client = remotehost;
  1065.     job->doneop = curJob->doneop;
  1066.     job->queued = curJob->queued;
  1067.     jobs[jobid] = job;
  1068.     curJob = job;
  1069.     return (true);
  1070. }
  1072. /*
  1073.  * Update the job's state on disk.
  1074.  */
  1075. bool
  1076. HylaFAXServer::updateJobOnDisk(Job& job, fxStr& emsg)
  1077. {
  1078.     if (job.fd < 0)
  1079.     {
  1080. job.fd = Sys::open("/" | job.qfile, O_RDWR|O_CREAT, jobProtection);
  1081. if (job.fd < 0)
  1082. {
  1083.     emsg = "Cannot open/create job description file /" | job.qfile;
  1084.     return false;
  1085. }
  1086.     }
  1088.     if (lockJob(job, LOCK_EX, emsg)) {
  1089. // XXX don't update in place, use temp file and rename
  1090. job.writeQFile();
  1091. unlockJob(job);
  1092. return (true);
  1093.     } else
  1094. return (false);
  1095. }
  1097. /*
  1098.  * Look for a job in the in-memory cache.
  1099.  */
  1100. Job*
  1101. HylaFAXServer::findJobInMemmory(const char* jobid)
  1102. {
  1103.     if (curJob->jobid == jobid) // fast check
  1104. return (curJob);
  1105.     Job** jpp = (Job**) jobs.find(jobid);
  1106.     if (jpp)
  1107. return (*jpp);
  1108.     return (jobid == defJob.jobid ? &defJob : (Job*) NULL);
  1109. }
  1111. /*
  1112.  * Look for a job on disk and, if found, read it
  1113.  * into memory and return it.
  1114.  */
  1115. Job*
  1116. HylaFAXServer::findJobOnDisk(const char* jid, fxStr& emsg)
  1117. {
  1118.     fxStr filename(fxStr::format("/" FAX_SENDDIR "/" FAX_QFILEPREF "%s", jid));
  1119.     struct stat sb;
  1120.     if (!FileCache::update(filename, sb)) {
  1121. /*
  1122.  * Not in sendq, look in the doneq for the job.
  1123.  */
  1124. filename = fxStr::format("/" FAX_DONEDIR "/" FAX_QFILEPREF "%s", jid);
  1125. if (!FileCache::update(filename, sb)) {
  1126.     emsg = fxStr::format("job does not exist (%s)", strerror(errno));
  1127.     return (NULL);
  1128. }
  1129.     }
  1130.     if (!S_ISREG(sb.st_mode)) {
  1131. emsg = "job description file is not a regular file";
  1132. return (NULL);
  1133.     }
  1134.     int fd = Sys::open(filename, O_RDWR);
  1135.     if (fd >= 0) {
  1136. // XXX should we lock here???
  1137. Job* req = new Job(&filename[1], fd);
  1138. bool reject;
  1139. if (req->readQFile(reject) && !reject) {
  1140.     Sys::close(req->fd), req->fd = -1;
  1141.     if (checkAccess(*req, T_JOB, A_READ) )
  1142. return (req);
  1143.     emsg = "Permission denied";
  1144.     delete req;
  1145.     return (NULL);
  1146. }
  1147. emsg = "invalid or corrupted job description file";
  1148. delete req; // NB: closes fd
  1149.     } else
  1150. emsg = fxStr::format("cannot open job description file %s (%s)",
  1151.     (const char*) filename, strerror(errno));
  1152.     return (NULL);
  1153. }
  1155. /*
  1156.  * Update a job's state from the on-disk copy.
  1157.  */
  1158. bool
  1159. HylaFAXServer::updateJobFromDisk(Job& job)
  1160. {
  1161.     bool status = false;
  1162.     if (lockJob(job, LOCK_SH)) {
  1163. bool reject;
  1164. status = (job.reReadQFile(reject) && !reject);
  1165. unlockJob(job);
  1166.     }
  1167.     return (status);
  1168. }
  1170. /*
  1171.  * Lock a job description file, creating it if
  1172.  * necessary.  Errors are not expected--if one
  1173.  * occurs a descriptive message is returned for
  1174.  * transmission to the client.
  1175.  */
  1176. bool
  1177. HylaFAXServer::lockJob(Job& job, int how, fxStr& emsg)
  1178. {
  1179.     if (job.fd < 0) {
  1180. job.fd = Sys::open("/" | job.qfile, O_RDWR, jobProtection);
  1181. if (job.fd < 0) {
  1182.     emsg = "Cannot open/create job description file /" | job.qfile;
  1183.     return (false);
  1184. }
  1185.     }
  1186.     if (flock(job.fd, how | LOCK_NB) >= 0)
  1187. return true;
  1189.     if (errno == EWOULDBLOCK && lockTimeout > 0)
  1190.     {
  1191. int r;
  1192. Timeout timer;
  1194. timer.startTimeout(lockTimeout*1000);
  1195. r = flock(job.fd, how);
  1196. timer.stopTimeout();
  1198. if (timer.wasTimeout())
  1199.     logDebug("LOCKWAIT timeout: %ds", lockTimeout);
  1201. return (r >= 0);
  1202.     }
  1204.     emsg = fxStr::format("Job file lock failed: %s", strerror(errno));
  1205.     Sys::close(job.fd);
  1206.     job.fd = -1;
  1207.     return (false);
  1208. }
  1211. /*
  1212.  * Like above, but no error message is returned.
  1213.  */
  1214. bool
  1215. HylaFAXServer::lockJob(Job& job, int how)
  1216. {
  1217.     if (job.fd < 0)
  1218.     {
  1219. job.fd = Sys::open("/" | job.qfile, O_RDWR, jobProtection);
  1220. if (job.fd < 0)
  1221.     return false;
  1222.     }
  1223.     if (flock(job.fd, how | LOCK_NB) >= 0)
  1224. return true;
  1226.     if (errno == EWOULDBLOCK && lockTimeout > 0)
  1227.     {
  1228. int r;
  1229. Timeout timer;
  1231. timer.startTimeout(lockTimeout * 1000);
  1232. r = flock(job.fd, how);
  1233. timer.stopTimeout();
  1235. if (timer.wasTimeout())
  1236.     logDebug("LOCKWAIT timeout: %ds", lockTimeout);
  1238. return (r >= 0);
  1239.     }
  1241.     return (false);
  1242. }
  1244. /*
  1245.  * Unlock a previously-locked job.
  1246.  */
  1247. void
  1248. HylaFAXServer::unlockJob(Job& job)
  1249. {
  1250.     if (job.fd >= 0)
  1251. Sys::close(job.fd), job.fd = -1; // implicit unlock
  1252. }
  1254. /*
  1255.  * Find a job either in memory (in the cache) or
  1256.  * on disk.  If a job is found in memory and the
  1257.  * on-disk state is more current, update the state
  1258.  * in the cache.
  1259.  */
  1260. Job*
  1261. HylaFAXServer::findJob(const char* jobid, fxStr& emsg)
  1262. {
  1263.     Job* job = findJobInMemmory(jobid);
  1264.     if (job) {
  1265. /*
  1266.  * Verify job is still around (another process has
  1267.  * not deleted it) and if the on-disk state has
  1268.  * been updated, re-read the job description file.
  1269.  */
  1270. if (!checkJobState(job)) {
  1271.             // We will re-check on disk in case a job was moved between queues
  1272.             job = NULL;
  1273.     emsg = "job deleted by another party";
  1274.         }
  1275.     } 
  1276.     if (!job) {
  1277. /*
  1278.  * We can only afford a certain amount of space,
  1279.  * unfortunately, there is no "bright" way to remove jobs
  1280.  * Ideally we'ld have an "aging" method, so the LRU job
  1281.  * would be the one deleted...
  1282.  */
  1283. if (jobs.size() > 10)
  1284. {
  1285.     JobDictIter iter(jobs);
  1286.     job = iter.value();
  1287.     jobs.remove(job->jobid);
  1288.     delete job;
  1289. }
  1291. job = findJobOnDisk(jobid, emsg);
  1292. if (job)
  1293.     jobs[job->jobid] = job;
  1294.     }
  1295.     return (job);
  1296. }
  1298. /*
  1299.  * Purge all in-memory job state.
  1300.  */
  1301. void
  1302. HylaFAXServer::purgeJobs(void)
  1303. {
  1304.     for (JobDictIter iter(jobs); iter.notDone(); iter++) {
  1305. Job* job = iter.value();
  1306. jobs.remove(job->jobid);
  1307. delete job;
  1308.     }
  1309. }
  1311. /*
  1312.  * Send a reply identifying the current job.
  1313.  */
  1314. void
  1315. HylaFAXServer::replyCurrentJob(const char* leader)
  1316. {
  1317.     if (curJob->jobid == "default")
  1318. reply(200, "%s (default).", leader);
  1319.     else
  1320. reply(200, "%s jobid: %s groupid: %s.", leader,
  1321.     (const char*) curJob->jobid, (const char*) curJob->groupid);
  1322. }
  1324. /*
  1325.  * Set the current job.
  1326.  */
  1327. void
  1328. HylaFAXServer::setCurrentJob(const char* jobid)
  1329. {
  1330.     fxStr emsg;
  1331.     Job* job = findJob(jobid, emsg);
  1332.     if (job) {
  1333. curJob = job;
  1334. replyCurrentJob("Current job:");
  1335.     } else
  1336. reply(500, "Cannot set job %s; %s.", jobid, (const char*) emsg);
  1337. }
  1339. /*
  1340.  * Reset a job's state to what is currently on disk.
  1341.  */
  1342. void
  1343. HylaFAXServer::resetJob(const char* jobid)
  1344. {
  1345.     fxStr emsg;
  1346.     Job* job = findJob(jobid, emsg);
  1347.     if (job) {
  1348. if (job->jobid == "default") {
  1349.     initDefaultJob();
  1350.     reply(200, "Default job reset to initial state.");
  1351. } else if (job->state != FaxRequest::state_suspended) {
  1352.     reply(504, "Job %s not reset; must be suspended.", jobid);
  1353. } else {
  1354.     updateJobFromDisk(*job);
  1355.     struct stat sb;
  1356.     if (FileCache::lookup("/" | job->qfile, sb))
  1357. job->lastmod = sb.st_mtime;
  1358.     reply(200, "Job %s reset to last state saved to disk.", jobid);
  1359. }
  1360.     } else
  1361. reply(500, "Cannot reset job %s; %s.", jobid, (const char*) emsg);
  1362. }
  1364. /*
  1365.  * Common work done for many job-related commands.
  1366.  */
  1367. Job*
  1368. HylaFAXServer::preJobCmd(const char* op, const char* jobid, fxStr& emsg)
  1369. {
  1370.     Job* job = findJob(jobid, emsg);
  1371.     if (job) {
  1372. if (job->jobid == "default") {
  1373.     reply(504, "Cannot %s default job.", op);
  1374.     job = NULL;
  1375. } else if (!IS(PRIVILEGED) && job->owner != the_user) {
  1376.     reply(504, "Cannot %s job: %s.", op, strerror(EPERM));
  1377.     job = NULL;
  1378. }
  1379.     } else
  1380. reply(500, "Cannot %s job %s; %s.", op, jobid, (const char*) emsg);
  1381.     return (job);
  1382. }
  1384. /*
  1385.  * Delete all job state (both on disk and in memory).
  1386.  */
  1387. void
  1388. HylaFAXServer::deleteJob(const char* jobid)
  1389. {
  1390.     fxStr emsg;
  1391.     Job* job = preJobCmd("delete", jobid, emsg);
  1392.     if (job) {
  1393. const char* startdir = cwd->pathname;
  1394. if (Sys::chdir("/") < 0) {
  1395.     reply(504, "Cannot change to base spool directory.");
  1396.     return;
  1397. }
  1398. if (job->state != FaxRequest::state_done &&
  1399.   job->state != FaxRequest::state_failed &&
  1400.   job->state != FaxRequest::state_suspended) {
  1401.     reply(504, "Job %s not deleted; use JSUSP first.", jobid);
  1402.     return;
  1403. }
  1404. if (!lockJob(*job, LOCK_EX, emsg)) {
  1405.     reply(504, "Cannot delete job: %s.", (const char*) emsg);
  1406.     return;
  1407. }
  1408. /*
  1409.  * Jobs in the doneq (state_done) have had their
  1410.  * documents converted to references (w/o links)
  1411.  * to the base document name; thus there is no
  1412.  * work to do to cleanup document state (a separate
  1413.  * scavenger program must deal with this since it
  1414.  * requires global knowledge of what jobs reference
  1415.  * what documents).
  1416.  *
  1417.  * Jobs that have yet to complete however hold links
  1418.  * to documents that must be removed.  We do this here
  1419.  * and also notify the scheduler about our work so that
  1420.  * it can properly expunge imaged versions of the docs.
  1421.  */
  1422. if (job->state == FaxRequest::state_suspended) {
  1423.     for (u_int i = 0, n = job->items.length(); i < n; i++) {
  1424. const FaxItem& fitem = job->items[i];
  1425. switch (fitem.op) {
  1426. case FaxRequest::send_fax:
  1427.     if (sendQueuerACK(emsg, "U%s", (const char*) fitem.item) ||
  1428.       !job->isUnreferenced(i))
  1429. break;
  1430.     /* ... fall thru */
  1431. case FaxRequest::send_tiff_saved:
  1432. case FaxRequest::send_tiff:
  1433. case FaxRequest::send_pdf_saved:
  1434. case FaxRequest::send_pdf:
  1435. case FaxRequest::send_postscript:
  1436. case FaxRequest::send_postscript_saved:
  1437. case FaxRequest::send_pcl:
  1438. case FaxRequest::send_pcl_saved:
  1439. case FaxRequest::send_data:
  1440.     Sys::unlink(fitem.item);
  1441.     break;
  1442. }
  1443.     }
  1444. } else {
  1445.     // expunge any cover page documents
  1446.     for (u_int i = 0, n = job->items.length(); i < n; i++) {
  1447. const FaxItem& fitem = job->items[i];
  1448. switch (fitem.op) {
  1449. case FaxRequest::send_tiff_saved:
  1450. case FaxRequest::send_tiff:
  1451. case FaxRequest::send_pdf_saved:
  1452. case FaxRequest::send_pdf:
  1453. case FaxRequest::send_postscript:
  1454. case FaxRequest::send_postscript_saved:
  1455. case FaxRequest::send_pcl:
  1456. case FaxRequest::send_pcl_saved:
  1457.     if (fitem.item.findR(fitem.item.length(), ".cover"))
  1458. Sys::unlink(fitem.item);
  1459.     break;
  1460. }
  1461.     }
  1462. }
  1463. if (Sys::unlink(job->qfile) < 0)
  1464.     reply(504, "Deletion of queue file %s failed.", (const char*) job->qfile);
  1465. if (Sys::chdir(startdir) < 0)
  1466.     reply(504, "Cannot change to %s spool directory.", startdir);
  1467. jobs.remove(job->jobid);
  1468. if (job == curJob) // make default job current
  1469.     curJob = &defJob;
  1470. delete job; // NB: implicit unlock
  1471. replyCurrentJob(fxStr::format("Job %s deleted; current job:", jobid));
  1472.     }
  1473. }
  1475. /*
  1476.  * Common work for doing job state manipulations.
  1477.  */
  1478. void
  1479. HylaFAXServer::operateOnJob(const char* jobid, const char* what, const char* op)
  1480. {
  1481.     fxStr emsg;
  1482.     Job* job = preJobCmd(what, jobid, emsg);
  1483.     if (job) {
  1484. if (job->state == FaxRequest::state_done ||
  1485.   job->state == FaxRequest::state_failed) {
  1486.     reply(504, "Job %s not %sed; already done.", jobid, what);
  1487.     return;
  1488. }
  1489. if (sendQueuerACK(emsg, "%s%s", op, jobid))
  1490.     reply(200, "Job %s %sed.", jobid, what);
  1491. else
  1492.     reply(460, "Failed to %s job %s: %s.",
  1493. what, jobid, (const char*) emsg);
  1494.     }
  1495. }
  1497. /*
  1498.  * Terminate a job, potentially aborting any call in progress.
  1499.  */
  1500. void
  1501. HylaFAXServer::killJob(const char* jobid)
  1502. {
  1503.     operateOnJob(jobid, "kill", "K");
  1504. }
  1506. /*
  1507.  * Suspend a job from being scheduled.
  1508.  */
  1509. void
  1510. HylaFAXServer::suspendJob(const char* jobid)
  1511. {
  1512.     operateOnJob(jobid, "suspend", "X");
  1513. }
  1515. /*
  1516.  * Interrupt a job from being scheduled.
  1517.  */
  1518. void
  1519. HylaFAXServer::interruptJob(const char* jobid)
  1520. {
  1521.     operateOnJob(jobid, "interrupt", "Y");
  1522. }
  1524. void
  1525. HylaFAXServer::replyBadJob(const Job& job, Token t)
  1526. {
  1527.     reply(504, "Cannot submit job %s; null or missing %s parameter.",
  1528. (const char*) job.jobid, parmToken(t));
  1529. }
  1531. /*
  1532.  * Submit a job for scheduling.
  1533.  */
  1534. void
  1535. HylaFAXServer::submitJob(const char* jobid)
  1536. {
  1537.     fxStr emsg;
  1538.     Job* job = preJobCmd("submit", jobid, emsg);
  1539.     if (job) {
  1540. if (job->state == FaxRequest::state_done ||
  1541.   job->state == FaxRequest::state_failed) {
  1542.     reply(504, "Job %s not submitted; already done.", jobid);
  1543.     return;
  1544. }
  1545. if (job->state != FaxRequest::state_suspended) {
  1546.     reply(504, "Job %s not submitted; use JSUSP first.", jobid);
  1547.     return;
  1548. }
  1549. if (job->number == "")
  1550.     replyBadJob(*job, T_DIALSTRING);
  1551. else if (job->mailaddr == "")
  1552.     replyBadJob(*job, T_NOTIFYADDR);
  1553. else if (job->sender == "")
  1554.     replyBadJob(*job, T_FROM_USER);
  1555. else if (job->modem == "")
  1556.     replyBadJob(*job, T_MODEM);
  1557. else if (job->client == "")
  1558.     replyBadJob(*job, T_CLIENT);
  1559. else {
  1560.     /*
  1561.      * If the client doesn't specify external then use number.  So
  1562.      * temporarily alter job->external as the job is updated on disk.
  1563.      */
  1564.     bool defaultexternal = false;
  1565.     if (job->external == "") {
  1566. job->external = job->number;
  1567. defaultexternal = true;
  1568.     }
  1569.     if (updateJobOnDisk(*job, emsg)) {
  1570. /*
  1571.  * NB: we don't mark the lastmod time for the
  1572.  * job since the scheduler should re-write the
  1573.  * queue file to reflect what it did with it
  1574.  * (e.g. what state it placed the job in).
  1575.  */
  1576. if (sendQueuerACK(emsg, "S%s", jobid)) {
  1577.     reply(200, "Job %s submitted.", jobid);
  1578.     Job** jpp = (Job**) blankJobs.find(job->jobid);
  1579.     if (jpp)
  1580. blankJobs.remove(job->jobid); // it's no longer blank
  1581. } else
  1582.     reply(460, "Failed to submit job %s: %s.",
  1583. jobid, (const char*) emsg);
  1584.     } else
  1585. reply(450, "%s.", (const char*) emsg); // XXX 550?
  1586.     if (defaultexternal)
  1587. job->external = "";
  1588. }
  1589.     }
  1590. }
  1592. /*
  1593.  * Wait for a job to complete or for the operation
  1594.  * to be aborted.  A data channel is opened and 
  1595.  * job status information is returned on it.  The
  1596.  * client can terminate this operation with an
  1597.  * ABOR command on the control channel; just like
  1598.  * a normal file transfer operation.
  1599.  */
  1600. void
  1601. HylaFAXServer::waitForJob(const char* jobid)
  1602. {
  1603.     fxStr emsg;
  1604.     Job* job = findJob(jobid, emsg);
  1605.     if (job) {
  1606. if (job->jobid == "default") {
  1607.     reply(504, "Cannot wait for default job.");
  1608.     return;
  1609. }
  1610. if (job->state == FaxRequest::state_done ||
  1611.   job->state == FaxRequest::state_failed) {
  1612.     reply(216, "Job %s done (already).", jobid);
  1613.     return;
  1614. }
  1615. state &= ~S_LOGTRIG; // just process events
  1616. if (newTrigger(emsg, "J<%s>%04x", jobid, 1<<Trigger::JOB_DEAD)) {
  1617.     // XXX is lreply the right thing?
  1618.     lreply(216, "Waiting for job %s; use ABOR command to interrupt.",
  1619. jobid);
  1620.     if (setjmp(urgcatch) == 0) {
  1621. Dispatcher& disp = Dispatcher::instance();
  1622. for (state |= S_WAITTRIG; IS(WAITTRIG); disp.dispatch()) {
  1623.     /*
  1624.      * The trigger event handlers update our notion
  1625.      * of the job state asynchronously so we can just
  1626.      * monitor the job's state variable.  Beware however
  1627.      * that the job may get removed/moved to the doneq
  1628.      * while we're monitoring its status; so we cannot
  1629.      * blindly hold a reference to the in-memory structure.
  1630.      */
  1631.     job = findJob(jobid, emsg);
  1632.     if (!job || job->state == FaxRequest::state_done ||
  1633.       job->state == FaxRequest::state_failed)
  1634. break;
  1635. }
  1636. reply(216, "Wait for job %s completed.", jobid);
  1637.     }
  1638.     state &= ~S_WAITTRIG;
  1639.     (void) cancelTrigger(emsg);
  1640. } else
  1641.     reply(504, "Cannot register trigger: %s.", (const char*) emsg);
  1642.     } else
  1643. reply(500, "Cannot wait for job %s; %s.", jobid, (const char*) emsg);
  1644. }
  1646. /*
  1647.  * Do common work used in adding a document to a
  1648.  * job's set of documents that are to be sent.
  1649.  */
  1650. bool
  1651. HylaFAXServer::checkAddDocument(Job& job, Token type,
  1652.     const char* docname, FaxSendOp& op)
  1653. {
  1654.     if (checkParm(job, type, A_WRITE)) {
  1655. struct stat sb;
  1656. if (fileAccess(docname, R_OK, sb)) {
  1657.     fxStr file(docname);
  1658.     u_int d = file.nextR(file.length(), '.');
  1659.     /*
  1660.      * We trust the client's protocol-specified (FORM) file format except 
  1661.      * in the case of Postscript because Postscript is the server-default 
  1662.      * (in the case the client did not specify the format).
  1663.      */
  1664.     if (strcmp(docname+d, "ps") != 0) {
  1665. for (u_int i = 0, n = N(formats); i < n; i++) {
  1666.     if (strcmp(docname+d, formats[i].suffix) == 0 && formats[i].supported) {
  1667. op = formats[i].op;
  1668. return (true);
  1669.     }
  1670. }
  1671.     }
  1672.     if (!docType(docname, op))
  1673. reply(550, "%s: Document type not recognized.", docname);
  1674.     else
  1675. return (true);
  1676. }
  1677.     }
  1678.     return (false);
  1679. }
  1681. /*
  1682.  * Add a cover document to the current job's
  1683.  * set of documents that are to be sent.
  1684.  */
  1685. void
  1686. HylaFAXServer::addCoverDocument(Job& job, const char* docname)
  1687. {
  1688.     FaxSendOp op;
  1689.     if (checkAddDocument(job, T_COVER, docname, op)) {
  1690. fxStr covername = "/" FAX_DOCDIR "/cover" | job.jobid | ".cover";
  1691. if (Sys::link(docname, covername) >= 0) {
  1692.     // XXX mark as cover page
  1693.     job.items.append(FaxItem(op, 0, "", &covername[1]));
  1694.     reply(200, "Added cover page document %s as %s.",
  1695. docname, &covername[1]);
  1696.     job.pagehandling = ""; // force recalculation
  1697. } else
  1698.     reply(550, "Unable to link cover page document %s to %s: %s.",
  1699. docname, (const char*) covername, strerror(errno));
  1700.     }
  1701. }
  1703. /*
  1704.  * Add a non-cover document to the current
  1705.  * job's set of documents that are to be sent.
  1706.  */
  1707. void
  1708. HylaFAXServer::addDocument(Job& job, const char* docname)
  1709. {
  1710.     FaxSendOp op;
  1711.     if (checkAddDocument(job, T_DOCUMENT, docname, op)) {
  1712. const char* cp = strrchr(docname, '/');
  1713. if (!cp) // relative name, e.g. doc123
  1714.     cp = docname;
  1715. fxStr document = fxStr::format("/" FAX_DOCDIR "%s.", cp) | job.jobid;
  1716. if (Sys::link(docname, document) >= 0) {
  1717.     job.items.append(FaxItem(op, 0, "", &document[1]));
  1718.     reply(200, "Added document %s as %s.", docname, &document[1]);
  1719.     job.pagehandling = ""; // force recalculation
  1720. } else
  1721.     reply(550, "Unable to link document %s to %s: %s.",
  1722. docname, (const char*) document, strerror(errno));
  1723.     }
  1724. }
  1726. /*
  1727.  * Add a polling operation to the current job.
  1728.  */
  1729. void
  1730. HylaFAXServer::addPollOp(Job& job, const char* sep, const char* pwd)
  1731. {
  1732.     if (checkParm(job, T_POLL, A_WRITE)) {
  1733. job.items.append(FaxItem(FaxRequest::send_poll, 0, sep, pwd));
  1734. reply(200, "Added poll operation.");
  1735.     }
  1736. }
  1738. /*
  1739.  * Directory interface support for querying job status.
  1740.  */
  1742. bool
  1743. HylaFAXServer::isVisibleSendQFile(const char* filename, const struct stat&)
  1744. {
  1745.     if (filename[0] == 'q') {
  1746.      fxStr emsg;
  1747.      Job* job = findJob(&filename[1], emsg);
  1748. if (job && checkAccess(*job, T_JOB, A_READ))
  1749.     return true;
  1750.     }
  1751.     if (strncmp(filename, FAX_SEQF, 4) == 0) return true;
  1752.     return false;
  1753. }
  1755. #ifdef roundup
  1756. #undef roundup
  1757. #endif
  1758. #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
  1760. /*
  1761.  * Return a compact notation for the specified
  1762.  * time.  This notation is guaranteed to fit in
  1763.  * a 7-character field.  We select one of 5
  1764.  * representations based on how close the time
  1765.  * is to ``now''.
  1766.  */
  1767. const char*
  1768. HylaFAXServer::compactTime(time_t t)
  1769. {
  1770.     time_t now = Sys::now();
  1771.     if (t > now) { // already past
  1772. static char buf[15];
  1773. const struct tm* tm = cvtTime(t);
  1774. if (t < roundup(now, 24*60*60)) // today, use 19:37
  1775.     strftime(buf, sizeof (buf), "%H:%M", tm);
  1776. else if (t < now+7*24*60*60) // within a week, use Sun 6pm
  1777.     strftime(buf, sizeof (buf), "%a%I%p", tm);
  1778. else // over a week, use 25Dec95
  1779.     strftime(buf, sizeof (buf), "%d%b%y", tm);
  1780. return (buf);
  1781.     } else
  1782. return ("");
  1783. }
  1785. static const char jformat[] = {
  1786.     's', // A (subaddr)
  1787.     's', // B (passwd)
  1788.     's', // C (company)
  1789.     's', // D (totdials & maxdials)
  1790.     'u', // E (desiredbr)
  1791.     's', // F (tagline)
  1792.     'u', // G (desiredst)
  1793.     'u', // H (desireddf)
  1794.     'u', // I (usrpri)
  1795.     's', // J (jobtag)
  1796.     'c', // K (desiredec as symbol)
  1797.     's', // L (location)
  1798.     's', // M (mailaddr)
  1799.     'c', // N (desiredtl as symbol)
  1800.     'c', // O (useccover as symbol)
  1801.     's', // P (npages & total pages)
  1802.     'u', // Q (minbr)
  1803.     's', // R (receiver)
  1804.     's', // S (sender)
  1805.     's', // T (tottries & maxtries)
  1806.     's', // U (chopthreshold)
  1807.     's', // V (doneop)
  1808.     's', // W (commid)
  1809.     'c', // X (jobtype as symbol)
  1810.     's', // Y (tts in strftime %Y/%m/%d %H.%M.%S format)
  1811.     'u', // Z (tts as decimal time_t)
  1812.     '[', // [
  1813.     '\', //  (must have something after the backslash)
  1814.     ']', // ]
  1815.     '^', // ^
  1816.     '_', // _
  1817.     '`', // `
  1818.     'c', // a (state as symbol)
  1819.     'u', // b (ntries)
  1820.     's', // c (client)
  1821.     'u', // d (totdials)
  1822.     's', // e (external)
  1823.     'u', // f (ndials)
  1824.     's', // g (groupid)
  1825.     'c', // h (pagechop as symbol)
  1826.     'u', // i (pri)
  1827.     's', // j (jobid)
  1828.     's', // k (killtime)
  1829.     'u', // l (pagelength)
  1830.     's', // m (modem)
  1831.     'c', // n (notify as symbol)
  1832.     's', // o (owner)
  1833.     'u', // p (npages)
  1834.     's', // q (retrytime)
  1835.     'u', // r (resolution)
  1836.     's', // s (notice a.k.a. status)
  1837.     'u', // t (tottries)
  1838.     'u', // u (maxtries)
  1839.     's', // v (number a.k.a dialstring)
  1840.     'u', // w (pagewidth)
  1841.     'u', // x (maxdials)
  1842.     'u', // y (total pages)
  1843.     's', // z (tts)
  1844.     'c', // 0 (usexvres as symbol)
  1845. };
  1847. /*
  1848.  * Print a formatted string with fields filled in from
  1849.  * the specified job's state.  This functionality is
  1850.  * used to permit clients to get job state listings in
  1851.  * preferred formats.
  1852.  */
  1853. void
  1854. HylaFAXServer::Jprintf(FILE* fd, const char* fmt, const Job& job)
  1855. {
  1856.     /*
  1857.      * Check once to see if the client has access to
  1858.      * privileged job state.  This typically is not
  1859.      * needed but doing it here eliminates the need to
  1860.      * do more work below (and the check should be fast).
  1861.      *
  1862.      * NB: This assumes that read access to T_DIALSTRING 
  1863.      *     implies read access to anything else in the
  1864.      *     job state that is protected.
  1865.      */
  1866.     bool haveAccess = checkAccess(job, T_DIALSTRING, A_READ);
  1867.     for (const char* cp = fmt; *cp; cp++) {
  1868. if (*cp == '%') {
  1869. #define MAXSPEC 20
  1870.     char fspec[MAXSPEC];
  1871.     char* fp = fspec;
  1872.     *fp++ = '%';
  1873.     char c = *++cp;
  1874.     if (c == '-')
  1875. *fp++ = c, c = *++cp;
  1876.     if (isdigit(c)) {
  1877. do {
  1878.     *fp++ = c;
  1879. } while (isdigit(c = *++cp) && fp < &fspec[MAXSPEC-3]);
  1880.     }
  1881.     if (c == '.') {
  1882. do {
  1883.     *fp++ = c;
  1884. } while (isdigit(c = *++cp) && fp < &fspec[MAXSPEC-2]);
  1885.     }
  1886.     if (!isalpha(c)) {
  1887. if (c == '%') // %% -> %
  1888.     putc(c, fd);
  1889. else
  1890.     fprintf(fd, "%.*s%c", fp-fspec, fspec, c);
  1891. continue;
  1892.     }
  1893.     fp[0] = jformat[c-'A']; // printf format string
  1894.     fp[1] = '';
  1895.             switch (c) {
  1896.     case 'A':
  1897. fprintf(fd, fspec, (const char*) job.subaddr);
  1898. break;
  1899.     case 'B':
  1900. fprintf(fd, fspec, haveAccess ? (const char*) job.passwd : "");
  1901. break;
  1902.     case 'C':
  1903. fprintf(fd, fspec, (const char*) job.company);
  1904. break;
  1905.     case 'D':
  1906. fprintf(fd, fspec, (const char*)fxStr::format("%2u:%-2u", job.totdials, job.maxdials));
  1907. break;
  1908.     case 'E':
  1909. fprintf(fd, fspec, job.desiredbr);
  1910. break;
  1911.     case 'F':
  1912. fprintf(fd, fspec, (const char*) job.tagline);
  1913. break;
  1914.     case 'G':
  1915. fprintf(fd, fspec, job.desiredst);
  1916. break;
  1917.     case 'H':
  1918. fprintf(fd, fspec, job.desireddf);
  1919. break;
  1920.     case 'I':
  1921. fprintf(fd, fspec, job.usrpri);
  1922. break;
  1923.     case 'J':
  1924. fprintf(fd, fspec, (const char*) job.jobtag);
  1925. break;
  1926.     case 'K':
  1927. fprintf(fd, fspec, "D HF"[job.desiredec]);
  1928. break;
  1929.     case 'L':
  1930. fprintf(fd, fspec, (const char*) job.location);
  1931. break;
  1932.     case 'M':
  1933. fprintf(fd, fspec, (const char*) job.mailaddr);
  1934. break;
  1935.     case 'N':
  1936. fprintf(fd, fspec, " P"[job.desiredtl]);
  1937. break;
  1938.     case 'O':
  1939. fprintf(fd, fspec, "N "[job.useccover]);
  1940. break;
  1941.     case 'P':
  1942. fprintf(fd, fspec, (const char*)fxStr::format("%2u:%-2u", job.npages, job.totpages));
  1943. break;
  1944.     case 'Q':
  1945. fprintf(fd, fspec, job.minbr);
  1946. break;
  1947.     case 'R':
  1948. fprintf(fd, fspec, (const char*) job.receiver);
  1949. break;
  1950.     case 'S':
  1951. fprintf(fd, fspec, (const char*) job.sender);
  1952. break;
  1953.     case 'T':
  1954. fprintf(fd, fspec, (const char*)fxStr::format("%2u:%-2u", job.tottries, job.maxtries));
  1955. break;
  1956.     case 'U':
  1957. fprintf(fd, fspec, (const char*)fxStr::format("%.1f", job.chopthreshold));
  1958. break;
  1959.     case 'V':
  1960. fprintf(fd, fspec, (const char*) job.doneop);
  1961. break;
  1962.     case 'W':
  1963. fprintf(fd, fspec, (const char*) job.commid);
  1964. break;
  1965.     case 'X':
  1966. fprintf(fd, fspec, toupper(job.jobtype[0]));
  1967. break;
  1968.     case 'Y':
  1969. { char buf[30]; // XXX HP C++
  1970.   strftime(buf, sizeof (buf), "%Y/%m/%d %H.%M.%S",
  1971. IS(USEGMT) ? gmtime(&job.tts) : localtime(&job.tts));
  1972.   fprintf(fd, fspec, buf);
  1973. }
  1974. break;
  1975.     case 'Z':
  1976. fprintf(fd, fspec, job.tts);
  1977. break;
  1978.     case 'a':
  1979. fprintf(fd, fspec, "?TPSBWRDF"[job.state]);
  1980. break;
  1981.     case 'b':
  1982. fprintf(fd, fspec, job.ntries);
  1983. break;
  1984.     case 'c':
  1985. fprintf(fd, fspec, (const char*) job.client);
  1986. break;
  1987.     case 'd':
  1988. fprintf(fd, fspec, job.totdials);
  1989. break;
  1990.     case 'e':
  1991. fprintf(fd, fspec, (const char*) job.external);
  1992. break;
  1993.     case 'f':
  1994. fprintf(fd, fspec, job.ndials);
  1995. break;
  1996.     case 'g':
  1997. fprintf(fd, fspec, (const char*) job.groupid);
  1998. break;
  1999.     case 'h':
  2000. fprintf(fd, fspec, " DAL"[job.pagechop]);
  2001. break;
  2002.     case 'i':
  2003. fprintf(fd, fspec, job.pri);
  2004. break;
  2005.     case 'j':
  2006. fprintf(fd, fspec, (const char*) job.jobid);
  2007. break;
  2008.     case 'k':
  2009. fprintf(fd, fspec, compactTime(job.killtime));
  2010. break;
  2011.     case 'l':
  2012. fprintf(fd, fspec, job.pagelength);
  2013. break;
  2014.     case 'm':
  2015. fprintf(fd, fspec, (const char*) job.modem);
  2016. break;
  2017.     case 'n':
  2018. fprintf(fd, fspec, " DQA"[job.notify]);
  2019. break;
  2020.     case 'o':
  2021. fprintf(fd, fspec, (const char*) job.owner);
  2022. break;
  2023.     case 'p':
  2024. fprintf(fd, fspec, job.npages);
  2025. break;
  2026.     case 'q':
  2027. fprintf(fd, fspec,
  2028.     job.retrytime == 0 ? "" : fmtTime(job.retrytime));
  2029. break;
  2030.     case 'r':
  2031. fprintf(fd, fspec, job.resolution);
  2032. break;
  2033.     case 's':
  2034. fprintf(fd, fspec, (const char*) job.notice);
  2035. break;
  2036.     case 't':
  2037. fprintf(fd, fspec, job.tottries);
  2038. break;
  2039.     case 'u':
  2040. fprintf(fd, fspec, job.maxtries);
  2041. break;
  2042.     case 'v':
  2043. fprintf(fd, fspec, haveAccess ? (const char*) job.number : "");
  2044. break;
  2045.     case 'w':
  2046. fprintf(fd, fspec, job.pagewidth);
  2047. break;
  2048.     case 'x':
  2049. fprintf(fd, fspec, job.maxdials);
  2050. break;
  2051.     case 'y':
  2052. fprintf(fd, fspec, job.totpages);
  2053. break;
  2054.     case 'z':
  2055. fprintf(fd, fspec, compactTime(job.tts));
  2056. break;
  2057.     case '0':
  2058. fprintf(fd, fspec, "N "[job.usexvres]);
  2059. break;
  2060.     }
  2061. } else
  2062.     putc(*cp, fd);
  2063.     }
  2064. }
  2066. void
  2067. HylaFAXServer::listSendQ(FILE* fd, const SpoolDir&, DIR* dir)
  2068. {
  2069.     fxStrArray files;
  2070.     struct dirent* dp;
  2071.     while ((dp = readdir(dir))) {
  2072. files.append(dp->d_name);
  2073.     }
  2074.     files.qsort();
  2075.     for (u_int i = 0, n = files.length(); i < n; i++) {
  2076. if (files[i][0] == 'q') {
  2077.     fxStr emsg;
  2078.     Job* job = findJob(&((const char*)files[i])[1], emsg);
  2079.     if (job) {
  2080. Jprintf(fd, jobFormat, *job);
  2081. fputs("rn", fd);
  2082.     }
  2083. }
  2084.     }
  2085. }
  2087. void
  2088. HylaFAXServer::listSendQFile(FILE* fd, const SpoolDir& dir,
  2089.     const char* filename, const struct stat& sb)
  2090. {
  2091.     fxStr emsg;
  2092.     Job* job = findJob(filename, emsg);
  2093.     if (job)
  2094. Jprintf(fd, jobFormat, *job);
  2095.     else
  2096. listUnixFile(fd, dir, filename, sb);
  2097. }
  2099. void
  2100. HylaFAXServer::nlstSendQ(FILE* fd, const SpoolDir&, DIR* dir)
  2101. {
  2102.     fxStrArray files;
  2103.     struct dirent* dp;
  2104.     while ((dp = readdir(dir))) {
  2105. files.append(dp->d_name);
  2106.     }
  2107.     files.qsort();
  2108.     for (u_int i = 0, n = files.length(); i < n; i++) {
  2109. if (files[i][0] == 'q') {
  2110.     fxStr emsg;
  2111.     Job* job = findJob(&((const char*)files[i])[1], emsg);
  2112.     if (job)
  2113. Jprintf(fd, "%jrn", *job);
  2114. }
  2115.     }
  2116. }
  2118. void
  2119. HylaFAXServer::nlstSendQFile(FILE* fd, const SpoolDir&,
  2120.     const char* filename, const struct stat&)
  2121. {
  2122.     fxStr emsg;
  2123.     Job* job = findJob(filename, emsg);
  2124.     if (job)
  2125. Jprintf(fd, "%j", *job);
  2126.     else
  2127. fprintf(fd, "%s", filename);
  2128. }