wvprint/lpdqueue.cc

   1 /*
   2  * Worldvisions Weaver Software:
   3  *   Copyright (C) 1997-2003 Net Integration Technologies, Inc.
   4  *
   5  * See lpdqueue.h.
   6  */
   7
   8 #include <wvtcp.h>
   9 #include <sys/stat.h>
  10 #include "lpdqueue.h"
  11
  12 struct LpdRequest
  13 {
  14     PrintJobInfoCallback cb;
  15     WvString buffer;
  16     WvString filename;
  17     WvFile* file;
  18     bool tmp;
  19     LpdRequest():
  20         buffer(), filename(), file(0), tmp(false) {}
  21     ~LpdRequest() {
  22         RELEASE(file);
  23         if (tmp)
  24             unlink(filename);
  25     }
  26 };
  27
  28 class WvTCPConnGC: public WvTCPConn
  29 {
  30 private:
  31     LpdRequest* req;
  32 public:
  33     WvTCPConnGC(WvStringParm _addr, LpdRequest* _req):
  34         WvTCPConn(_addr), req(_req) {}
  35     virtual ~WvTCPConnGC() {
  36         if (req)
  37             delete req;
  38     }
  39 };
  40
  41 PrintQueueLPD::PrintQueueLPD(WvStringParm _name, const UniConf _cfg,
  42                              WvLog& _log):
  43     PrintQueue(_name, _cfg, _log)
  44 {
  45     WvString sectionname("queues/%s", name);
  46     remotePrinter = Unknown;
  47
  48     if (cfg[sectionname]["lpdserver"].exists())
  49     {
  50         if (cfg[sectionname]["networkprinter"].getme(0))
  51             remotePrinter = Network;
  52         else
  53             remotePrinter = NetIntegrator;
  54     }
  55
  56     if (cfg[sectionname].exists() &&
  57         ((remotePrinter == Network) || (remotePrinter == NetIntegrator)))
  58     {
  59         if (cfg[sectionname]["queue"].exists())
  60           remotequeue = cfg[sectionname]["queue"].getme(name);
  61         else
  62           remotequeue = WvString("lp");
  63
  64         serveraddr  = cfg[sectionname]["lpdserver"].getme(0);
  65
  66         if (!serveraddr)
  67         {
  68             log(WvLog::Error, "LPD queue %s does not have a server\n", _name);
  69             return;
  70         }
  71
  72         if (!strchr(serveraddr, ':'))
  73             serveraddr.append(":printer");
  74     }
  75     else if (remotePrinter == Unknown)
  76     {
  77         /* error here, this shouldn't happen, we should know what type
  78            of remote server we're using */
  79         log(WvLog::Error, "Uknown remote server type! (%s)\n", _name);
  80         return;
  81     }
  82
  83     log(WvLog::Debug, "Set up LPD bounce queue %s, to queue %s on %s\n",
  84                         name, remotequeue, serveraddr);
  85 }
  86
  87 void PrintQueueLPD::callback_filter(bool ok, void* userdata)
  88 {
  89     LpdRequest* req = static_cast<LpdRequest*>(userdata);
  90     WvTCPConn* conn;
  91
  92     if (ok)
  93     {
  94         RELEASE(req->file);
  95
  96         req->file = new WvFile(req->filename, O_RDONLY);
  97         if (!req->file->isok())
  98         {
  99             log(WvLog::Error, "there is a problem reading the spool file %s (%s)\n", req->filename, req->file->errstr());
 100             delete req;
 101             return;
 102         }
 103
 104         conn = new WvTCPConnGC(serveraddr, req);
 105
 106         log(WvLog::Debug, "sending off job %s to queue %s on LPD server %s\n", active->get_id(), remotequeue, serveraddr);
 107
 108         /* remote queues may have different names than our named remote queue, so
 109           assume that it's going to be lp@<hostname> */
 110         conn->print("\2%s\n", remotequeue);
 111
 112         conn->alarm(15000);
 113         conn->setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_submit_job), req);
 114         activelist.append(conn, true);
 115     }
 116     else
 117         delete req;
 118 }
 119
 120 void PrintQueueLPD::callback_submit_job(WvStream &s, void* userdata)
 121 {
 122     LpdRequest* req = static_cast<LpdRequest*>(userdata);
 123     char buf;
 124
 125     if (s.alarm_was_ticking)
 126     {
 127         log(WvLog::Error,
 128             "connection to queue %s of LPD server %s timed out\n",
 129             remotequeue, serveraddr);
 130         s.close();
 131         return;
 132     }
 133
 134     if (s.read(&buf, 1))
 135     {
 136         if (!buf)
 137         {
 138             log(WvLog::Debug, "receive printer job command accepted\n");
 139
 140             req->buffer = WvString("H%s\n"
 141                                    "P%s\n"
 142                                    "J%s\n"
 143                                    "C%s\n"
 144                                    "L%s\n"
 145                                    "fdfA%03s%s\n"
 146                                    "UdfA%03s%s\n"
 147                                    "N%s\n",
 148                                    active->hostname,
 149                                    active->username,
 150                                    active->jobname,
 151                                    active->hostname,
 152                                    active->username,
 153                                    active->get_id(),
 154                                    active->hostname,
 155                                    active->get_id(),
 156                                    active->hostname,
 157                                    active->spoolInfo->filename);
 158
 159             s.print("\2%s cfA%03s%s\n", req->buffer.len(), active->get_id(), active->hostname);
 160             s.alarm(15000);
 161             s.setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_submit_control), req);
 162         }
 163         else
 164         {
 165             log(WvLog::Error,
 166                 "LPD server %s (queue %s) refused our job %s\n",
 167                 serveraddr, remotequeue, active->get_id());
 168             s.close();
 169         }
 170     }
 171 }
 172
 173 void PrintQueueLPD::callback_submit_control(WvStream &s, void* userdata)
 174 {
 175     LpdRequest* req = static_cast<LpdRequest*>(userdata);
 176     char buf;
 177
 178     if (s.alarm_was_ticking)
 179     {
 180         log(WvLog::Error,
 181             "connection to queue %s of LPD server %s timed out\n",
 182             remotequeue, serveraddr);
 183         s.close();
 184         return;
 185     }
 186
 187     if (s.read(&buf, 1))
 188     {
 189         if (!buf)
 190         {
 191             log(WvLog::Debug, "receive control file command accepted\n");
 192             s.print(req->buffer);
 193             s.write("\0", 1);
 194             s.alarm(15000);
 195             s.setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_submit_data), req);
 196         }
 197         else
 198         {
 199             log(WvLog::Error,
 200                 "LPD server %s (queue %s) refused our job %s (control file)\n",
 201                 serveraddr, remotequeue, active->get_id());
 202             s.close();
 203         }
 204     }
 205 }
 206
 207 void PrintQueueLPD::callback_submit_data(WvStream &s, void* userdata)
 208 {
 209     LpdRequest* req = static_cast<LpdRequest*>(userdata);
 210     struct stat si;
 211     char buf;
 212
 213     if (s.alarm_was_ticking)
 214     {
 215         log(WvLog::Error,
 216             "connection to queue %s of LPD server %s timed out\n",
 217             remotequeue, serveraddr);
 218         s.close();
 219         return;
 220     }
 221
 222     if (s.read(&buf, 1))
 223     {
 224         if (!buf)
 225         {
 226             log(WvLog::Debug, "control file accepted\n");
 227
 228             if (stat(req->filename, &si) == -1)
 229             {
 230                 log(WvLog::Error, "error getting %s information: %s\n", req->filename, strerror(errno));
 231                 s.close();
 232             }
 233             else
 234             {
 235                 s.print("\3%s dfA%03s%s\n", si.st_size, active->get_id(), active->hostname);
 236                 s.alarm(15000);
 237                 s.setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_submit_ack_data), req);
 238             }
 239         }
 240         else
 241         {
 242             log(WvLog::Error,
 243                 "LPD server %s (queue %s) refused our job %s (control file)\n",
 244                 serveraddr, remotequeue, active->get_id());
 245             s.close();
 246         }
 247     }
 248 }
 249
 250 void PrintQueueLPD::callback_submit_ack_data(WvStream &s, void* userdata)
 251 {
 252     LpdRequest* req = static_cast<LpdRequest*>(userdata);
 253     char buf;
 254
 255     if (s.alarm_was_ticking)
 256     {
 257         log(WvLog::Error,
 258             "connection to queue %s of LPD server %s timed out\n",
 259             remotequeue, serveraddr);
 260         s.close();
 261         return;
 262     }
 263
 264     if (s.read(&buf, 1))
 265     {
 266         if (!buf)
 267         {
 268             log(WvLog::Debug, "receive data file command accepted\n");
 269
 270             s.alarm(15000);
 271             s.force_select(false, true);
 272             s.setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_submit_send_data), req);
 273         }
 274         else
 275         {
 276             log(WvLog::Error,
 277                 "LPD server %s (queue %s) refused our job %s\n",
 278                 serveraddr, remotequeue, active->get_id());
 279             s.close();
 280         }
 281     }
 282 }
 283
 284 void PrintQueueLPD::callback_submit_send_data(WvStream &s, void* userdata)
 285 {
 286     LpdRequest* req = static_cast<LpdRequest*>(userdata);
 287     char buf[4096];
 288     size_t len;
 289
 290     if (s.alarm_was_ticking)
 291     {
 292         log(WvLog::Error,
 293             "connection to queue %s of LPD server %s timed out\n",
 294             remotequeue, serveraddr);
 295         s.close();
 296         return;
 297     }
 298     else
 299     {
 300         len = req->file->read(buf, sizeof(buf));
 301         s.write(buf, len);
 302         s.alarm(15000);
 303
 304         if (!req->file->isok())
 305         {
 306             s.write("\0", 1);
 307             s.undo_force_select(false, true);
 308             s.setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_submit_send_data_fin), req);
 309         }
 310     }
 311 }
 312
 313 void PrintQueueLPD::callback_submit_send_data_fin(WvStream &s, void* userdata)
 314 {
 315     char buf;
 316
 317     if (s.alarm_was_ticking)
 318     {
 319         log(WvLog::Error,
 320             "connection to queue %s of LPD server %s timed out\n",
 321             remotequeue, serveraddr);
 322         s.close();
 323         return;
 324     }
 325     else
 326     {
 327         if (s.read(&buf, 1))
 328         {
 329             s.close();
 330             if (!buf)
 331             {
 332                 active->finished();
 333                 jobs.unlink(active);
 334                 active = 0;
 335             }
 336         }
 337     }
 338 }
 339
 340 void PrintQueueLPD::print_job(PrintJob* job)
 341 {
 342     LpdRequest* req;
 343     WvFile* in;
 344
 345     if (active || activelist.count())
 346         return;
 347
 348     active = job;
 349
 350     req = new struct LpdRequest;
 351
 352     in = new WvFile(active->get_file(), O_RDONLY);
 353     if (!in->isok())
 354     {
 355         log(WvLog::Error, "there is a problem reading the spool file %s (%s)\n", job->get_file(), in->errstr());
 356         RELEASE(in);
 357     }
 358
 359     if (filter)
 360     {
 361         WvFile* tmp;
 362
 363         req->filename = WvString("%s/%03s-tmp", spool, active->get_id());
 364         req->tmp = true;
 365
 366         tmp = new WvFile(req->filename, O_CREAT|O_WRONLY|O_TRUNC);
 367         if (!tmp->isok())
 368         {
 369             log(WvLog::Error, "there is a problem writing the temporary file %s (%s)\n", req->filename, tmp->errstr());
 370             RELEASE(tmp);
 371             RELEASE(in);
 372             return;
 373         }
 374
 375         req->file = tmp;
 376
 377         do_filter(in, true, *tmp, PrintFilterCallback(this, &PrintQueueLPD::callback_filter), req);
 378     }
 379     else
 380     {
 381         req->filename = active->get_file();
 382         callback_filter(true, req);
 383     }
 384 }
 385
 386 void PrintQueueLPD::callback_lpq(WvStream &s, void* userdata)
 387 {
 388     LpdRequest* req = static_cast<LpdRequest*>(userdata);
 389     char* str;
 390
 391     str = s.getline(0);
 392     if (str)
 393     {
 394         req->buffer.append("%s\n", str);
 395     }
 396
 397     if (s.alarm_was_ticking)
 398     {
 399         req->buffer.append("\nconnection timed out");
 400         log(WvLog::Warning, req->buffer);
 401         s.close();
 402     }
 403
 404     if (!s.isok())
 405     {
 406         lpq_crap = req->buffer;
 407         req->cb(0);
 408     }
 409 }
 410
 411 void PrintQueueLPD::foreach(const PrintJobInfoCallback& cb)
 412 {
 413     PrintJobList::Iter i(jobs);
 414     PrintJobInfo info;
 415     unsigned int pos;
 416     struct stat si;
 417     LpdRequest* req = new LpdRequest;
 418     WvTCPConn* conn = new WvTCPConnGC(serveraddr, req);
 419
 420     req->cb = cb;
 421     req->buffer = "\nRemote LPD queue status:\n";
 422
 423     log(WvLog::Debug, "the server address is %s\n", *conn->src());
 424
 425      if (!jobs.isempty() && jobs.first() == active)
 426         pos = 0;
 427     else
 428         pos = 1;
 429
 430     i.rewind();
 431     while (i.next())
 432     {
 433         if (i().is_complete())
 434         {
 435             info.position = pos++;
 436             info.id = i().get_id();
 437             info.username = i().username;
 438             info.filename = i().spoolInfo->filename;
 439
 440             if (stat(i().get_file(), &si) == -1)
 441             {
 442                 log(WvLog::Error, "error getting %s information: %s\n", i().get_file(), strerror(errno));
 443                 si.st_size = 0;
 444             }
 445
 446             info.size = si.st_size;
 447
 448             cb(&info);
 449         }
 450     }
 451
 452     /* The callback will take care of calling cb(0) at the appropriate
 453      * time. */
 454     conn->print("\3%s\n", remotequeue);
 455     conn->alarm(15000);
 456     conn->setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_lpq), req);
 457     append(conn, true);
 458 }
 459
 460 void PrintQueueLPD::callback_lprm(WvStream &s, void* userdata)
 461 {
 462     char buf[1024];
 463
 464     if (s.alarm_was_ticking)
 465     {
 466         log(WvLog::Warning, "lprm connection to queue %s on LPD server %s timed out\n", remotequeue, serveraddr);
 467         s.close();
 468         return;
 469     }
 470
 471     if (s.read(buf, sizeof(buf)))
 472         s.alarm(15000);
 473
 474     if (!s.isok())
 475         log(WvLog::Debug2, "lprm connection to queue %s on LPD server %s finished\n", remotequeue, serveraddr);
 476 }
 477
 478 bool PrintQueueLPD::cancel(unsigned short id, WvStringParm agent)
 479 {
 480     bool found = PrintQueue::cancel(id, agent);
 481     WvTCPConn* conn;
 482
 483     if (!found)
 484     {
 485         conn = new WvTCPConn(serveraddr);
 486         conn->print("\5%s %s %s\n", remotequeue, agent, id);
 487         conn->alarm(15000);
 488         conn->setcallback(WvStreamCallback(this, &PrintQueueLPD::callback_lprm), 0);
 489         append(conn, true);
 490     }
 491
 492     return true;
 493 }
 494
 495 bool PrintQueueLPD::isok() const
 496 {
 497     return serveraddr && PrintQueue::isok();
 498 }
 499