wvprint/queue.cc

   1 /*
   2  * Worldvisions Weaver Software:
   3  *   Copyright (C) 1997-2003 Net Integration Technologies, Inc.
   4  *
   5  * This is the PrintQueue class for handling various queue functions
   6  * under WvPrint.
   7  */
   8 #include <wvpipe.h>
   9 #include <wvtimeoutstream.h>
  10 #include <sys/stat.h>
  11 #include <sys/types.h>
  12 #include "queue.h"
  13 #include "localqueue.h"
  14 #include "lpdqueue.h"
  15
  16 const unsigned int MAX_JOBS = 1000;
  17
  18 PrintQueue* PrintQueue::new_queue(WvStringParm name, const UniConf cfg,
  19                                   WvLog& log)
  20 {
  21     WvString sectionname("queues/%s", name);
  22     const UniConf section = cfg[sectionname];
  23     PrintQueue* queue = 0;
  24
  25     do {
  26         /* We're not in charge of queue aliases, shouldn't happen. */
  27         if (section["alias"].exists())
  28         {
  29             queue = 0;
  30             break;
  31         }
  32
  33         if (section["device"].exists())
  34         {
  35             queue = new PrintQueueLocal(name, cfg, log);
  36             break;
  37         }
  38
  39         if (section["lpdserver"].exists() || section["remotehost"].exists())
  40         {
  41             queue = new PrintQueueLPD(name, cfg, log);
  42             break;
  43         }
  44     } while (0);
  45
  46     if (queue)
  47     {
  48         if (!queue->isok())
  49         {
  50             RELEASE(queue);
  51         }
  52     }
  53
  54     return queue;
  55 }
  56
  57 PrintQueue::PrintQueue(WvStringParm _name, const UniConf _cfg, WvLog &_log):
  58     last(0), filter_callback(0), userdata(0), cfg(_cfg), log(_log),
  59     active(0), name(_name), lpq_crap()
  60 {
  61     reconfig();
  62
  63     append(&activelist, false);
  64
  65     log(WvLog::Debug, "Setting up queue %s in %s\n", name, spool);
  66 }
  67
  68 void PrintQueue::reconfig()
  69 {
  70     WvString sectionname("queues/%s", name);
  71
  72     if (!spool)
  73     {
  74         spool = cfg["spooldir"].getme("/var/spool/wvprint");
  75         spool = WvString("%s/%s", spool, name);
  76     }
  77
  78     filter = cfg[sectionname]["filter"].getme("");
  79 }
  80
  81 bool PrintQueue::pre_select(SelectInfo& si)
  82 {
  83     if (active && (activelist.count() == 0))
  84     {
  85         log(WvLog::Debug, "it seems there was a problem printing job %s\n",
  86             active->get_id());
  87         active = 0;
  88         activelist.append(new WvTimeoutStream(5000), true);
  89     }
  90
  91     return (!active && !jobs.isempty() && (activelist.count() == 0) && jobs.first()->is_complete()) || WvIStreamList::pre_select(si);
  92 }
  93
  94 void PrintQueue::execute()
  95 {
  96     WvIStreamList::execute();
  97
  98     if (jobs.isempty() || active || activelist.count())
  99         return;
 100
 101     print_job(jobs.first());
 102
 103     if (!active)
 104         activelist.append(new WvTimeoutStream(5000), true);
 105 }
 106
 107 PrintJob* PrintQueue::new_job()
 108 {
 109     PrintJobList::Iter i(jobs);
 110     PrintJob *job;
 111     unsigned short next = last + 1;
 112
 113     /* Here, we try to create the spool directory, because we try to be
 114      * helpful, but we don't try too hard. We let errors be logged when
 115      * the directory is actually used, so the user can correct them and
 116      * try again without needing to restart the daemon.
 117      */
 118     mkdir(spool, 0755);
 119
 120     /* If there are too many jobs in the queue, we just puke, hoping
 121        it'll get better. */
 122     if (jobs.count() >= 999)
 123         return NULL;
 124
 125     if (next == MAX_JOBS)
 126         next = 1;
 127
 128     /* Despite how evil this looks, we are going through the job list
 129      * looking for a "free" slot for this job
 130      */
 131     i.rewind();
 132     while (i.next())
 133     {
 134         if (i->get_id() == next)
 135         {
 136             i.rewind();
 137             ++next;
 138             if (next == MAX_JOBS)
 139                 next = 1;
 140         }
 141     }
 142
 143     last = next;
 144
 145     job = new PrintJob(log, *this, last, spool);
 146
 147     jobs.append(job, true);
 148
 149     return job;
 150 }
 151
 152 bool PrintQueue::cancel(unsigned short id, WvStringParm agent)
 153 {
 154     PrintJobList::Iter i(jobs);
 155     bool found = false;
 156
 157     i.rewind();
 158     while (i.next())
 159     {
 160         if (i().get_id() == id)
 161         {
 162             found = true;
 163             break;
 164         }
 165     }
 166
 167     if (found)
 168     {
 169         if ((strcmp(agent, i().username) == 0) || (strcmp(agent, "root") == 0))
 170         {
 171             if (i.ptr() == active)
 172             {
 173                 zap();
 174                 append(&activelist, false);
 175                 active = 0;
 176             }
 177
 178             log(WvLog::Info, "job %s on queue %s canceled by %s\n", id, name, agent);
 179             jobs.unlink(i.ptr());
 180
 181             /* Kill off the active stream */
 182             activelist.zap();
 183         }
 184         else
 185         {
 186             log(WvLog::Warning, "user %s tried to cancel job %s on queue %s owned by another user\n", agent, id, name);
 187             found = false;
 188         }
 189     }
 190     else
 191         log(WvLog::Warning, "trying to cancel non-existent job %s on queue %s\n", id, name);
 192
 193     return found;
 194 }
 195
 196 unsigned int PrintQueue::get_active_id() const
 197 {
 198     return active ? active->get_id() : 0;
 199 }
 200
 201 size_t PrintQueue::job_count() const
 202 {
 203     return jobs.count();
 204 }
 205
 206 void PrintQueue::callback_pipe(WvStream& s, void*)
 207 {
 208     WvPipe& pipe = static_cast<WvPipe&>(s);
 209     char buf[1];
 210     size_t len;
 211
 212     len = pipe.read(buf, sizeof(buf));
 213     if (len)
 214         log(WvLog::Debug, "callback_pipe actually read some bytes from the pipe, that's strange...");
 215
 216     if (!pipe.isok())
 217     {
 218         bool ok = false;
 219
 220         if (pipe.child_exited())
 221         {
 222             if (pipe.child_killed())
 223             {
 224                 log(WvLog::Error, "filter for job %s killed with signal %s\n", active->get_id(), pipe.exit_status());
 225             }
 226             else
 227             {
 228                 if (pipe.exit_status())
 229                 {
 230                     log(WvLog::Debug, strerror(pipe.exit_status()));
 231                     log(WvLog::Error, "filter for job %s exited with return code %s\n", active->get_id(), pipe.exit_status());
 232                 }
 233                 else
 234                     ok = true;
 235             }
 236         }
 237         else
 238         {
 239             log(WvLog::Error, "pipe is not ok, but child is still alive?");
 240         }
 241
 242         if (!! filter_callback)
 243             filter_callback(ok, userdata);
 244     }
 245 }
 246
 247 void PrintQueue::callback_forward(WvStream& s, void*)
 248 {
 249     char buf[1024];
 250     size_t len;
 251
 252     len = s.read(buf, sizeof(buf));
 253     s.read_requires_writable->write(buf, len);
 254
 255     if (!s.isok())
 256         if (!! filter_callback)
 257             filter_callback(true, userdata);
 258 }
 259
 260 void PrintQueue::do_filter(WvFile* in, bool auto_delete,
 261     WvFDStream& out, const PrintFilterCallback& _cb, void* _userdata)
 262 {
 263     if (!active || !in->isok() || !out.isok() || !_cb)
 264         return;
 265
 266     filter_callback = _cb;
 267     userdata = _userdata;
 268
 269     if (!!filter)
 270     {
 271         WvPipe* pipe;
 272         const char *args[] = {0, 0};
 273
 274         args[0] = filter.edit();
 275
 276         pipe = new WvPipe(args[0], args, false, false, false,
 277             in->getrfd(), out.getwfd());
 278
 279         in->close();
 280         if (auto_delete)
 281             RELEASE(in);
 282
 283         if (pipe->isok())
 284         {
 285             pipe->setcallback(WvStreamCallback(this, &PrintQueue::callback_pipe), 0);
 286             activelist.append(pipe, true);
 287             out.close();
 288         }
 289         else
 290         {
 291             log(WvLog::Error, "there is a problem with the print filter (%s): %s\n", filter, pipe->errstr());
 292             RELEASE(pipe);
 293         }
 294     }
 295     else
 296     {
 297         log(WvLog::Debug, "No filter defined for %s\n", name);
 298
 299         in->read_requires_writable = &out;
 300
 301         in->setcallback(WvStreamCallback(this, &PrintQueue::callback_forward), 0);
 302
 303         activelist.append(in, auto_delete);
 304     }
 305 }
 306
 307 bool PrintQueue::increase_priority(unsigned int job_id)
 308 {
 309     PrintJobList::Iter i(jobs);
 310     i.rewind();
 311     while (i.next() && i().get_id() != job_id)
 312         { }
 313
 314     if (i().get_id() == job_id)
 315     {
 316         PrintJob *tempjob = new PrintJob(*i);
 317         jobs.unlink(&(*i));
 318         jobs.prepend(tempjob, true);
 319     }
 320     else
 321         return false;
 322
 323     return true;
 324 }