cfe194ab1739b4ff3e326f6332c92e311c34ee1a
[samba.git] / source3 / printing / printing.c
1 #define OLD_NTDOMAIN 1
2 /* 
3    Unix SMB/Netbios implementation.
4    Version 3.0
5    printing backend routines
6    Copyright (C) Andrew Tridgell 1992-2000
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24
25 extern int DEBUGLEVEL;
26
27 /* 
28    the printing backend revolves around a tdb database that stores the
29    SMB view of the print queue 
30    
31    The key for this database is a jobid - a internally generated number that
32    uniquely identifies a print job
33
34    reading the print queue involves two steps:
35      - possibly running lpq and updating the internal database from that
36      - reading entries from the database
37
38    jobids are assigned when a job starts spooling. 
39 */
40
41 struct printjob {
42         pid_t pid; /* which process launched the job */
43         int sysjob; /* the system (lp) job number */
44         int fd; /* file descriptor of open file if open */
45         time_t starttime; /* when the job started spooling */
46         int status; /* the status of this job */
47         size_t size; /* the size of the job so far */
48         BOOL spooled; /* has it been sent to the spooler yet? */
49         BOOL smbjob; /* set if the job is a SMB job */
50         fstring filename; /* the filename used to spool the file */
51         fstring jobname; /* the job name given to us by the client */
52         fstring user; /* the user who started the job */
53         fstring qname; /* name of the print queue the job was sent to */
54 };
55
56 /* the open printing.tdb database */
57 static TDB_CONTEXT *tdb;
58 static pid_t local_pid;
59
60 #define PRINT_MAX_JOBID 10000
61 #define UNIX_JOB_START PRINT_MAX_JOBID
62
63 #define PRINT_SPOOL_PREFIX "smbprn."
64 #define PRINT_DATABASE_VERSION 2
65
66 static int get_queue_status(int, print_status_struct *);
67
68 /****************************************************************************
69 initialise the printing backend. Called once at startup. 
70 Does not survive a fork
71 ****************************************************************************/
72 BOOL print_backend_init(void)
73 {
74         char *sversion = "INFO/version";
75
76         if (tdb && local_pid == sys_getpid()) return True;
77         tdb = tdb_open(lock_path("printing.tdb"), 0, 0, O_RDWR|O_CREAT, 0600);
78         if (!tdb) {
79                 DEBUG(0,("Failed to open printing backend database\n"));
80         }
81         local_pid = sys_getpid();
82
83         /* handle a Samba upgrade */
84         tdb_lock_bystring(tdb, sversion);
85         if (tdb_fetch_int(tdb, sversion) != PRINT_DATABASE_VERSION) {
86                 tdb_traverse(tdb, (tdb_traverse_func)tdb_delete, NULL);
87                 tdb_store_int(tdb, sversion, PRINT_DATABASE_VERSION);
88         }
89         tdb_unlock_bystring(tdb, sversion);
90
91         return nt_printing_init();
92 }
93
94 /****************************************************************************
95 useful function to generate a tdb key
96 ****************************************************************************/
97 static TDB_DATA print_key(int jobid)
98 {
99         static int j;
100         TDB_DATA ret;
101
102         j = jobid;
103         ret.dptr = (void *)&j;
104         ret.dsize = sizeof(j);
105         return ret;
106 }
107
108 /****************************************************************************
109 useful function to find a print job in the database
110 ****************************************************************************/
111 static struct printjob *print_job_find(int jobid)
112 {
113         static struct printjob pjob;
114         TDB_DATA ret;
115
116         ret = tdb_fetch(tdb, print_key(jobid));
117         if (!ret.dptr || ret.dsize != sizeof(pjob)) return NULL;
118
119         memcpy(&pjob, ret.dptr, sizeof(pjob));
120         free(ret.dptr);
121         return &pjob;
122 }
123
124 /****************************************************************************
125 store a job structure back to the database
126 ****************************************************************************/
127 static BOOL print_job_store(int jobid, struct printjob *pjob)
128 {
129         TDB_DATA d;
130         d.dptr = (void *)pjob;
131         d.dsize = sizeof(*pjob);
132
133         return (tdb_store(tdb, print_key(jobid), d, TDB_REPLACE) == 0);
134 }
135
136 /****************************************************************************
137 run a given print command 
138 a null terminated list of value/substitute pairs is provided
139 for local substitution strings
140 ****************************************************************************/
141 static int print_run_command(int snum,char *command, 
142                              char *outfile,
143                              ...)
144 {
145         pstring syscmd;
146         char *p, *arg;
147         int ret;
148         va_list ap;
149
150         if (!command || !*command) return -1;
151
152         if (!VALID_SNUM(snum)) {
153                 DEBUG(0,("Invalid snum %d for command %s\n", snum, command));
154                 return -1;
155         }
156
157         pstrcpy(syscmd, command);
158
159         va_start(ap, outfile);
160         while ((arg = va_arg(ap, char *))) {
161                 char *value = va_arg(ap,char *);
162                 pstring_sub(syscmd, arg, value);
163         }
164         va_end(ap);
165   
166         p = PRINTERNAME(snum);
167         if (!p || !*p) p = SERVICE(snum);
168   
169         pstring_sub(syscmd, "%p", p);
170         standard_sub_snum(snum,syscmd);
171
172         /* Convert script args to unix-codepage */
173         dos_to_unix(syscmd, True);
174         ret = smbrun(syscmd,outfile,False);
175
176         DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
177
178         return ret;
179 }
180
181
182 /****************************************************************************
183 parse a file name from the system spooler to generate a jobid
184 ****************************************************************************/
185 static int print_parse_jobid(char *fname)
186 {
187         int jobid;
188
189         if (strncmp(fname,PRINT_SPOOL_PREFIX,strlen(PRINT_SPOOL_PREFIX)) != 0) return -1;
190         fname += strlen(PRINT_SPOOL_PREFIX);
191
192         jobid = atoi(fname);
193         if (jobid <= 0) return -1;
194
195         return jobid;
196 }
197
198
199 /****************************************************************************
200 list a unix job in the print database
201 ****************************************************************************/
202 static void print_unix_job(int snum, print_queue_struct *q)
203 {
204         int jobid = q->job + UNIX_JOB_START;
205         struct printjob pj, *old_pj;
206
207         /* Preserve the timestamp on an existing unix print job */
208
209         old_pj = print_job_find(jobid);
210
211         ZERO_STRUCT(pj);
212
213         pj.pid = (pid_t)-1;
214         pj.sysjob = q->job;
215         pj.fd = -1;
216         pj.starttime = old_pj ? old_pj->starttime : q->time;
217         pj.status = q->status;
218         pj.size = q->size;
219         pj.spooled = True;
220         pj.smbjob = False;
221         fstrcpy(pj.filename, "");
222         fstrcpy(pj.jobname, q->file);
223         fstrcpy(pj.user, q->user);
224         fstrcpy(pj.qname, lp_servicename(snum));
225
226         print_job_store(jobid, &pj);
227 }
228
229
230 struct traverse_struct {
231         print_queue_struct *queue;
232         int qcount, snum, maxcount;
233 };
234
235 /* utility fn to delete any jobs that are no longer active */
236 static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
237 {
238         struct traverse_struct *ts = (struct traverse_struct *)state;
239         struct printjob pjob;
240         int i, jobid;
241
242         if (data.dsize != sizeof(pjob) || key.dsize != sizeof(int)) return 0;
243         memcpy(&jobid, key.dptr, sizeof(jobid));
244         memcpy(&pjob,  data.dptr, sizeof(pjob));
245
246         if (strcmp(lp_servicename(ts->snum), pjob.qname)) {
247                 /* this isn't for the queue we are looking at */
248                 return 0;
249         }
250
251         if (!pjob.smbjob) {
252                 /* remove a unix job if it isn't in the system queue
253                    any more */
254
255                 for (i=0;i<ts->qcount;i++) {
256                         if (jobid == ts->queue[i].job + UNIX_JOB_START) break;
257                 }
258                 if (i == ts->qcount) tdb_delete(tdb, key);
259                 return 0;
260         }
261
262         /* maybe it hasn't been spooled yet */
263         if (!pjob.spooled) {
264                 /* if a job is not spooled and the process doesn't
265                    exist then kill it. This cleans up after smbd
266                    deaths */
267                 if (!process_exists(pjob.pid)) {
268                         tdb_delete(tdb, key);
269                 }
270                 return 0;
271         }
272
273         for (i=0;i<ts->qcount;i++) {
274                 int qid = print_parse_jobid(ts->queue[i].file);
275                 if (jobid == qid) break;
276         }
277         
278         /* The job isn't in the system queue - we have to assume it has
279            completed, so delete the database entry. */
280
281         if (i == ts->qcount) {
282                 time_t cur_t = time(NULL);
283
284                 /* A race can occur between the time a job is spooled and
285                    when it appears in the lpq output.  This happens when
286                    the job is added to printing.tdb when another smbd
287                    running print_queue_update() has completed a lpq and
288                    is currently traversing the printing tdb and deleting jobs.
289                    A workaround is to not delete the job if it has been 
290                    submitted less than lp_lpqcachetime() seconds ago. */
291
292                 if ((cur_t - pjob.starttime) > lp_lpqcachetime()) {
293                         tdb_delete(t, key);
294                 }
295         }
296
297         return 0;
298 }
299
300 /****************************************************************************
301 check if the print queue has been updated recently enough
302 ****************************************************************************/
303 static void print_cache_flush(int snum)
304 {
305         fstring key;
306         slprintf(key, sizeof(key), "CACHE/%s", lp_servicename(snum));
307         tdb_store_int(tdb, key, -1);
308 }
309
310 /****************************************************************************
311 update the internal database from the system print queue for a queue
312 ****************************************************************************/
313 static void print_queue_update(int snum)
314 {
315         char *path = lp_pathname(snum);
316         char *cmd = lp_lpqcommand(snum);
317         char **qlines;
318         pstring tmp_file;
319         int numlines, i, qcount;
320         print_queue_struct *queue = NULL;
321         print_status_struct status;
322         print_status_struct old_status;
323         struct printjob *pjob;
324         struct traverse_struct tstruct;
325         fstring keystr, printer_name;
326         TDB_DATA data, key;
327  
328         fstrcpy(printer_name, lp_servicename(snum));
329         
330         /*
331          * Update the cache time FIRST ! Stops others doing this
332          * if the lpq takes a long time.
333          */
334
335         slprintf(keystr, sizeof(keystr), "CACHE/%s", printer_name);
336         tdb_store_int(tdb, keystr, (int)time(NULL));
337
338         slprintf(tmp_file, sizeof(tmp_file), "%s/smblpq.%d", path, local_pid);
339
340         unlink(tmp_file);
341         print_run_command(snum, cmd, tmp_file, NULL);
342
343         numlines = 0;
344         qlines = file_lines_load(tmp_file, &numlines, True);
345         unlink(tmp_file);
346
347         /* turn the lpq output into a series of job structures */
348         qcount = 0;
349         ZERO_STRUCT(status);
350         if (numlines)
351                 queue = (print_queue_struct *)malloc(sizeof(print_queue_struct)*(numlines+1));
352
353         if (queue) {
354                 for (i=0; i<numlines; i++) {
355                         /* parse the line */
356                         if (parse_lpq_entry(snum,qlines[i],
357                                             &queue[qcount],&status,qcount==0)) {
358                                 qcount++;
359                         }
360                 }               
361         }
362         file_lines_free(qlines);
363
364         DEBUG(3, ("%d job%s in queue for %s\n", qcount, (qcount != 1) ?
365                 "s" : "", printer_name));
366
367         /* Lock the queue for the database update */
368
369         slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", printer_name);
370         tdb_lock_bystring(tdb, keystr);
371
372         /*
373           any job in the internal database that is marked as spooled
374           and doesn't exist in the system queue is considered finished
375           and removed from the database
376
377           any job in the system database but not in the internal database 
378           is added as a unix job
379
380           fill in any system job numbers as we go
381         */
382         for (i=0; i<qcount; i++) {
383                 int jobid = print_parse_jobid(queue[i].file);
384
385                 if (jobid == -1) {
386                         /* assume its a unix print job */
387                         print_unix_job(snum, &queue[i]);
388                         continue;
389                 }
390
391                 /* we have an active SMB print job - update its status */
392                 pjob = print_job_find(jobid);
393                 if (!pjob) {
394                         /* err, somethings wrong. Probably smbd was restarted
395                            with jobs in the queue. All we can do is treat them
396                            like unix jobs. Pity. */
397                         print_unix_job(snum, &queue[i]);
398                         continue;
399                 }
400
401                 pjob->sysjob = queue[i].job;
402                 pjob->status = queue[i].status;
403
404                 print_job_store(jobid, pjob);
405         }
406
407         /* now delete any queued entries that don't appear in the
408            system queue */
409         tstruct.queue = queue;
410         tstruct.qcount = qcount;
411         tstruct.snum = snum;
412
413         tdb_traverse(tdb, traverse_fn_delete, (void *)&tstruct);
414
415         safe_free(tstruct.queue);
416
417         /*
418          * Get the old print status. We will use this to compare the
419          * number of jobs. If they have changed we need to send a
420          * "changed" message to the smbds.
421          */
422
423         if( qcount != get_queue_status(snum, &old_status)) {
424                 DEBUG(10,("print_queue_update: queue status change %d jobs -> %d jobs for printer %s\n",
425                                 old_status.qcount, qcount, printer_name ));
426                 message_send_all(conn_tdb_ctx(), MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
427         }
428
429         /* store the new queue status structure */
430         slprintf(keystr, sizeof(keystr), "STATUS/%s", printer_name);
431         key.dptr = keystr;
432         key.dsize = strlen(keystr);
433
434         status.qcount = qcount;
435         data.dptr = (void *)&status;
436         data.dsize = sizeof(status);
437         tdb_store(tdb, key, data, TDB_REPLACE); 
438
439         /* Unlock for database update */
440
441         slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", printer_name);
442         tdb_unlock_bystring(tdb, keystr);
443
444         /*
445          * Update the cache time again. We want to do this call
446          * as little as possible...
447          */
448
449         slprintf(keystr, sizeof(keystr), "CACHE/%s", printer_name);
450         tdb_store_int(tdb, keystr, (int)time(NULL));
451 }
452
453 /****************************************************************************
454 check if a jobid is valid. It is valid if it exists in the database
455 ****************************************************************************/
456 BOOL print_job_exists(int jobid)
457 {
458         return tdb_exists(tdb, print_key(jobid));
459 }
460
461
462 /****************************************************************************
463 work out which service a jobid is for
464 note that we have to look up by queue name to ensure that it works for 
465 other than the process that started the job
466 ****************************************************************************/
467 int print_job_snum(int jobid)
468 {
469         struct printjob *pjob = print_job_find(jobid);
470         if (!pjob) return -1;
471
472         return lp_servicenumber(pjob->qname);
473 }
474
475 /****************************************************************************
476 give the fd used for a jobid
477 ****************************************************************************/
478 int print_job_fd(int jobid)
479 {
480         struct printjob *pjob = print_job_find(jobid);
481         if (!pjob) return -1;
482         /* don't allow another process to get this info - it is meaningless */
483         if (pjob->pid != local_pid) return -1;
484         return pjob->fd;
485 }
486
487 /****************************************************************************
488 give the filename used for a jobid
489 only valid for the process doing the spooling and when the job
490 has not been spooled
491 ****************************************************************************/
492 char *print_job_fname(int jobid)
493 {
494         struct printjob *pjob = print_job_find(jobid);
495         if (!pjob || pjob->spooled || pjob->pid != local_pid) return NULL;
496         return pjob->filename;
497 }
498
499
500 /****************************************************************************
501 set the place in the queue for a job
502 ****************************************************************************/
503 BOOL print_job_set_place(int jobid, int place)
504 {
505         DEBUG(2,("print_job_set_place not implemented yet\n"));
506         return False;
507 }
508
509 /****************************************************************************
510 set the name of a job. Only possible for owner
511 ****************************************************************************/
512 BOOL print_job_set_name(int jobid, char *name)
513 {
514         struct printjob *pjob = print_job_find(jobid);
515         if (!pjob || pjob->pid != local_pid) return False;
516
517         fstrcpy(pjob->jobname, name);
518         return print_job_store(jobid, pjob);
519 }
520
521
522 /****************************************************************************
523 delete a print job - don't update queue
524 ****************************************************************************/
525 static BOOL print_job_delete1(int jobid)
526 {
527         struct printjob *pjob = print_job_find(jobid);
528         int snum;
529
530         if (!pjob) return False;
531
532         snum = print_job_snum(jobid);
533
534         if (pjob->spooled && pjob->sysjob != -1) {
535                 /* need to delete the spooled entry */
536                 fstring jobstr;
537                 slprintf(jobstr, sizeof(jobstr), "%d", pjob->sysjob);
538                 print_run_command(snum, 
539                                   lp_lprmcommand(snum), NULL,
540                                   "%j", jobstr,
541                                   "%T", http_timestring(pjob->starttime),
542                                   NULL);
543         }
544
545         return True;
546 }
547
548 /****************************************************************************
549 return true if the current user owns the print job
550 ****************************************************************************/
551 static BOOL is_owner(struct current_user *user, int jobid)
552 {
553         struct printjob *pjob = print_job_find(jobid);
554         user_struct *vuser;
555
556         if (!pjob || !user) return False;
557
558         if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
559                 return strequal(pjob->user, vuser->user.smb_name);
560         } else {
561                 return strequal(pjob->user, uidtoname(user->uid));
562         }
563 }
564
565 /****************************************************************************
566 delete a print job
567 ****************************************************************************/
568 BOOL print_job_delete(struct current_user *user, int jobid, int *errcode)
569 {
570         int snum = print_job_snum(jobid);
571         char *printer_name;
572         BOOL owner;
573         
574         owner = is_owner(user, jobid);
575         
576         /* Check access against security descriptor or whether the user
577            owns their job. */
578
579         if (!owner && 
580             !print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
581                 DEBUG(3, ("delete denied by security descriptor\n"));
582                 *errcode = ERROR_ACCESS_DENIED;
583                 return False;
584         }
585
586         if (!print_job_delete1(jobid)) return False;
587
588         /* force update the database and say the delete failed if the
589            job still exists */
590
591         print_queue_update(snum);
592
593         /* Send a printer notify message */
594
595         printer_name = PRINTERNAME(snum);
596
597         message_send_all(conn_tdb_ctx(), MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
598
599         return !print_job_exists(jobid);
600 }
601
602
603 /****************************************************************************
604 pause a job
605 ****************************************************************************/
606 BOOL print_job_pause(struct current_user *user, int jobid, int *errcode)
607 {
608         struct printjob *pjob = print_job_find(jobid);
609         int snum, ret = -1;
610         char *printer_name;
611         fstring jobstr;
612         BOOL owner;
613         
614         if (!pjob || !user) return False;
615
616         if (!pjob->spooled || pjob->sysjob == -1) return False;
617
618         snum = print_job_snum(jobid);
619         owner = is_owner(user, jobid);
620
621         if (!owner &&
622             !print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
623                 DEBUG(3, ("pause denied by security descriptor\n"));
624                 *errcode = ERROR_ACCESS_DENIED;
625                 return False;
626         }
627
628         /* need to pause the spooled entry */
629         slprintf(jobstr, sizeof(jobstr), "%d", pjob->sysjob);
630         ret = print_run_command(snum, 
631                                 lp_lppausecommand(snum), NULL,
632                                 "%j", jobstr,
633                                 NULL);
634
635         if (ret != 0) {
636                 *errcode = ERROR_INVALID_PARAMETER;
637                 return False;
638         }
639
640         /* force update the database */
641         print_cache_flush(snum);
642
643         /* Send a printer notify message */
644
645         printer_name = PRINTERNAME(snum);
646
647         message_send_all(conn_tdb_ctx(), MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
648
649         /* how do we tell if this succeeded? */
650
651         return True;
652 }
653
654 /****************************************************************************
655 resume a job
656 ****************************************************************************/
657 BOOL print_job_resume(struct current_user *user, int jobid, int *errcode)
658 {
659         struct printjob *pjob = print_job_find(jobid);
660         char *printer_name;
661         int snum, ret;
662         fstring jobstr;
663         BOOL owner;
664         
665         if (!pjob || !user) return False;
666
667         if (!pjob->spooled || pjob->sysjob == -1) return False;
668
669         snum = print_job_snum(jobid);
670         owner = is_owner(user, jobid);
671
672         if (!is_owner(user, jobid) &&
673             !print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
674                 DEBUG(3, ("resume denied by security descriptor\n"));
675                 *errcode = ERROR_ACCESS_DENIED;
676                 return False;
677         }
678
679         slprintf(jobstr, sizeof(jobstr), "%d", pjob->sysjob);
680         ret = print_run_command(snum, 
681                                 lp_lpresumecommand(snum), NULL,
682                                 "%j", jobstr,
683                                 NULL);
684
685         if (ret != 0) {
686                 *errcode = ERROR_INVALID_PARAMETER;
687                 return False;
688         }
689
690         /* force update the database */
691         print_cache_flush(snum);
692
693         /* Send a printer notify message */
694
695         printer_name = PRINTERNAME(snum);
696
697         message_send_all(conn_tdb_ctx(),MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
698
699         return True;
700 }
701
702 /****************************************************************************
703 write to a print file
704 ****************************************************************************/
705 int print_job_write(int jobid, const char *buf, int size)
706 {
707         int fd;
708
709         fd = print_job_fd(jobid);
710         if (fd == -1) return -1;
711
712         return write(fd, buf, size);
713 }
714
715 /****************************************************************************
716  Check if the print queue has been updated recently enough.
717 ****************************************************************************/
718
719 static BOOL print_cache_expired(int snum)
720 {
721         fstring key;
722         time_t t2, t = time(NULL);
723
724         slprintf(key, sizeof(key), "CACHE/%s", lp_servicename(snum));
725         t2 = tdb_fetch_int(tdb, key);
726         if (t2 == ((time_t)-1) || (t - t2) >= lp_lpqcachetime()) {
727                 DEBUG(3, ("print cache expired\n"));
728                 return True;
729         }
730         return False;
731 }
732
733 /****************************************************************************
734  Get the queue status - do not update if db is out of date.
735 ****************************************************************************/
736
737 static int get_queue_status(int snum, print_status_struct *status)
738 {
739         fstring keystr;
740         TDB_DATA data, key;
741
742         ZERO_STRUCTP(status);
743         slprintf(keystr, sizeof(keystr), "STATUS/%s", lp_servicename(snum));
744         key.dptr = keystr;
745         key.dsize = strlen(keystr);
746         data = tdb_fetch(tdb, key);
747         if (data.dptr) {
748                 if (data.dsize == sizeof(print_status_struct)) {
749                         memcpy(status, data.dptr, sizeof(print_status_struct));
750                 }
751                 free(data.dptr);
752         }
753         return status->qcount;
754 }
755
756 /****************************************************************************
757  Determine the number of jobs in a queue.
758 ****************************************************************************/
759
760 static int print_queue_length(int snum)
761 {
762         print_status_struct status;
763
764         /* make sure the database is up to date */
765         if (print_cache_expired(snum)) print_queue_update(snum);
766
767         /* also fetch the queue status */
768         return get_queue_status(snum, &status);
769 }
770
771 /***************************************************************************
772 start spooling a job - return the jobid
773 ***************************************************************************/
774 int print_job_start(struct current_user *user, int snum, char *jobname)
775 {
776         int jobid;
777         char *path;
778         struct printjob pjob;
779         int next_jobid;
780         user_struct *vuser;
781
782         errno = 0;
783
784         if (!print_access_check(user, snum, PRINTER_ACCESS_USE)) {
785                 DEBUG(3, ("print_job_start: job start denied by security descriptor\n"));
786                 return -1;
787         }
788
789         if (!print_time_access_check(snum)) {
790                 DEBUG(3, ("print_job_start: job start denied by time check\n"));
791                 return -1;
792         }
793
794         path = lp_pathname(snum);
795
796         /* see if we have sufficient disk space */
797         if (lp_minprintspace(snum)) {
798                 SMB_BIG_UINT dspace, dsize;
799                 if (sys_fsusage(path, &dspace, &dsize) == 0 &&
800                     dspace < 2*(SMB_BIG_UINT)lp_minprintspace(snum)) {
801                         errno = ENOSPC;
802                         return -1;
803                 }
804         }
805
806         /* for autoloaded printers, check that the printcap entry still exists */
807         if (lp_autoloaded(snum) && !pcap_printername_ok(lp_servicename(snum), NULL)) {
808                 errno = ENOENT;
809                 return -1;
810         }
811
812         if (lp_maxprintjobs(snum) && print_queue_length(snum) > lp_maxprintjobs(snum)) {
813                 errno = ENOSPC;
814                 return -1;
815         }
816
817         /* create the database entry */
818         ZERO_STRUCT(pjob);
819         pjob.pid = local_pid;
820         pjob.sysjob = -1;
821         pjob.fd = -1;
822         pjob.starttime = time(NULL);
823         pjob.status = LPQ_QUEUED;
824         pjob.size = 0;
825         pjob.spooled = False;
826         pjob.smbjob = True;
827
828         fstrcpy(pjob.jobname, jobname);
829
830         if ((vuser = get_valid_user_struct(user->vuid)) != NULL) {
831                 fstrcpy(pjob.user, vuser->user.smb_name);
832         } else {
833                 fstrcpy(pjob.user, uidtoname(user->uid));
834         }
835
836         fstrcpy(pjob.qname, lp_servicename(snum));
837
838         /* lock the database */
839         tdb_lock_bystring(tdb, "INFO/nextjob");
840
841  next_jobnum:
842         next_jobid = tdb_fetch_int(tdb, "INFO/nextjob");
843         if (next_jobid == -1) next_jobid = 1;
844
845         for (jobid = next_jobid+1; jobid != next_jobid; ) {
846                 if (!print_job_exists(jobid)) break;
847                 jobid = (jobid + 1) % PRINT_MAX_JOBID;
848                 if (jobid == 0) jobid = 1;
849         }
850         if (jobid == next_jobid || !print_job_store(jobid, &pjob)) {
851                 jobid = -1;
852                 goto fail;
853         }
854
855         tdb_store_int(tdb, "INFO/nextjob", jobid);
856
857         /* we have a job entry - now create the spool file 
858
859            we unlink first to cope with old spool files and also to beat
860            a symlink security hole - it allows us to use O_EXCL 
861            There may be old spool files owned by other users lying around.
862         */
863         slprintf(pjob.filename, sizeof(pjob.filename), "%s/%s%d", 
864                  path, PRINT_SPOOL_PREFIX, jobid);
865         if (unlink(pjob.filename) == -1 && errno != ENOENT) {
866                 goto next_jobnum;
867         }
868         pjob.fd = sys_open(pjob.filename,O_WRONLY|O_CREAT|O_EXCL,0600);
869         if (pjob.fd == -1) goto fail;
870
871         print_job_store(jobid, &pjob);
872
873         tdb_unlock_bystring(tdb, "INFO/nextjob");
874
875         /*
876          * If the printer is marked as postscript output a leading
877          * file identifier to ensure the file is treated as a raw
878          * postscript file.
879          * This has a similar effect as CtrlD=0 in WIN.INI file.
880          * tim@fsg.com 09/06/94
881          */
882         if (lp_postscript(snum)) {
883                 print_job_write(jobid, "%!\n",3);
884         }
885
886         return jobid;
887
888  fail:
889         if (jobid != -1) {
890                 tdb_delete(tdb, print_key(jobid));
891         }
892
893         tdb_unlock_bystring(tdb, "INFO/nextjob");
894         return -1;
895 }
896
897 /****************************************************************************
898  Print a file - called on closing the file. This spools the job.
899 ****************************************************************************/
900
901 BOOL print_job_end(int jobid)
902 {
903         struct printjob *pjob = print_job_find(jobid);
904         int snum;
905         SMB_STRUCT_STAT sbuf;
906         pstring current_directory;
907         pstring print_directory;
908         char *wd, *p, *printer_name;
909         pstring jobname;
910
911         if (!pjob)
912                 return False;
913
914         if (pjob->spooled || pjob->pid != local_pid)
915                 return False;
916
917         snum = print_job_snum(jobid);
918
919         if (sys_fstat(pjob->fd, &sbuf) == 0)
920                 pjob->size = sbuf.st_size;
921
922         close(pjob->fd);
923         pjob->fd = -1;
924
925         if (pjob->size == 0) {
926                 /* don't bother spooling empty files */
927                 unlink(pjob->filename);
928                 tdb_delete(tdb, print_key(jobid));
929                 return True;
930         }
931
932         /* we print from the directory path to give the best chance of
933            parsing the lpq output */
934         wd = sys_getwd(current_directory);
935         if (!wd)
936                 return False;           
937
938         pstrcpy(print_directory, pjob->filename);
939         p = strrchr(print_directory,'/');
940         if (!p)
941                 return False;
942         *p++ = 0;
943
944         if (chdir(print_directory) != 0)
945                 return False;
946
947         pstrcpy(jobname, pjob->jobname);
948         pstring_sub(jobname, "'", "_");
949
950         /* send it to the system spooler */
951         print_run_command(snum, 
952                           lp_printcommand(snum), NULL,
953                           "%s", p,
954                           "%J", jobname,
955                           "%f", p,
956                           NULL);
957
958         chdir(wd);
959
960         pjob->spooled = True;
961         print_job_store(jobid, pjob);
962
963         /* force update the database */
964         print_cache_flush(snum);
965         
966         /* Send a printer notify message */
967
968         printer_name = PRINTERNAME(snum);
969
970         message_send_all(conn_tdb_ctx(),MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
971
972         return True;
973 }
974
975 /* utility fn to enumerate the print queue */
976 static int traverse_fn_queue(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
977 {
978         struct traverse_struct *ts = (struct traverse_struct *)state;
979         struct printjob pjob;
980         int i, jobid;
981
982         if (data.dsize != sizeof(pjob) || key.dsize != sizeof(int)) return 0;
983         memcpy(&jobid, key.dptr, sizeof(jobid));
984         memcpy(&pjob,  data.dptr, sizeof(pjob));
985
986         /* maybe it isn't for this queue */
987         if (ts->snum != print_queue_snum(pjob.qname)) return 0;
988
989         if (ts->qcount >= ts->maxcount) return 0;
990
991         i = ts->qcount;
992
993         ts->queue[i].job = jobid;
994         ts->queue[i].size = pjob.size;
995         ts->queue[i].status = pjob.status;
996         ts->queue[i].priority = 1;
997         ts->queue[i].time = pjob.starttime;
998         fstrcpy(ts->queue[i].user, pjob.user);
999         fstrcpy(ts->queue[i].file, pjob.jobname);
1000
1001         ts->qcount++;
1002
1003         return 0;
1004 }
1005
1006 struct traverse_count_struct {
1007         int snum, count;
1008 };
1009
1010 /* utility fn to count the number of entries in the print queue */
1011 static int traverse_count_fn_queue(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
1012 {
1013         struct traverse_count_struct *ts = (struct traverse_count_struct *)state;
1014         struct printjob pjob;
1015         int jobid;
1016
1017         if (data.dsize != sizeof(pjob) || key.dsize != sizeof(int)) return 0;
1018         memcpy(&jobid, key.dptr, sizeof(jobid));
1019         memcpy(&pjob,  data.dptr, sizeof(pjob));
1020
1021         /* maybe it isn't for this queue */
1022         if (ts->snum != print_queue_snum(pjob.qname)) return 0;
1023
1024         ts->count++;
1025
1026         return 0;
1027 }
1028
1029 /* Sort print jobs by submittal time */
1030
1031 static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2)
1032 {
1033         /* Silly cases */
1034
1035         if (!j1 && !j2) return 0;
1036         if (!j1) return -1;
1037         if (!j2) return 1;
1038
1039         /* Sort on job start time */
1040
1041         if (j1->time == j2->time) return 0;
1042         return (j1->time > j2->time) ? 1 : -1;
1043 }
1044
1045 /****************************************************************************
1046 get a printer queue listing
1047 ****************************************************************************/
1048 int print_queue_status(int snum, 
1049                        print_queue_struct **queue,
1050                        print_status_struct *status)
1051 {
1052         struct traverse_struct tstruct;
1053         struct traverse_count_struct tsc;
1054         fstring keystr;
1055         TDB_DATA data, key;
1056
1057         /* make sure the database is up to date */
1058         if (print_cache_expired(snum)) print_queue_update(snum);
1059
1060         *queue = NULL;
1061         
1062         /*
1063          * Fetch the queue status.  We must do this first, as there may
1064          * be no jobs in the queue.
1065          */
1066         ZERO_STRUCTP(status);
1067         slprintf(keystr, sizeof(keystr), "STATUS/%s", lp_servicename(snum));
1068         key.dptr = keystr;
1069         key.dsize = strlen(keystr);
1070         data = tdb_fetch(tdb, key);
1071         if (data.dptr) {
1072                 if (data.dsize == sizeof(*status)) {
1073                         memcpy(status, data.dptr, sizeof(*status));
1074                 }
1075                 free(data.dptr);
1076         }
1077
1078         /*
1079          * Now, fetch the print queue information.  We first count the number
1080          * of entries, and then only retrieve the queue if necessary.
1081          */
1082         tsc.count = 0;
1083         tsc.snum = snum;
1084         
1085         tdb_traverse(tdb, traverse_count_fn_queue, (void *)&tsc);
1086
1087         if (tsc.count == 0)
1088                 return 0;
1089
1090         /* Allocate the queue size. */
1091         if ((tstruct.queue = (print_queue_struct *)
1092              malloc(sizeof(print_queue_struct)*tsc.count))
1093                                 == NULL)
1094                 return 0;
1095
1096         /*
1097          * Fill in the queue.
1098          * We need maxcount as the queue size may have changed between
1099          * the two calls to tdb_traverse.
1100          */
1101         tstruct.qcount = 0;
1102         tstruct.maxcount = tsc.count;
1103         tstruct.snum = snum;
1104
1105         tdb_traverse(tdb, traverse_fn_queue, (void *)&tstruct);
1106
1107         /* Sort the queue by submission time otherwise they are displayed
1108            in hash order. */
1109
1110         qsort(tstruct.queue, tstruct.qcount, sizeof(print_queue_struct),
1111               QSORT_CAST(printjob_comp));
1112
1113         *queue = tstruct.queue;
1114         return tstruct.qcount;
1115 }
1116
1117
1118 /****************************************************************************
1119 turn a queue name into a snum
1120 ****************************************************************************/
1121 int print_queue_snum(char *qname)
1122 {
1123         int snum = lp_servicenumber(qname);
1124         if (snum == -1 || !lp_print_ok(snum)) return -1;
1125         return snum;
1126 }
1127
1128
1129 /****************************************************************************
1130  pause a queue
1131 ****************************************************************************/
1132 BOOL print_queue_pause(struct current_user *user, int snum, int *errcode)
1133 {
1134         char *printer_name;
1135         int ret;
1136         
1137         if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
1138                 *errcode = ERROR_ACCESS_DENIED;
1139                 return False;
1140         }
1141
1142         ret = print_run_command(snum, lp_queuepausecommand(snum), NULL, 
1143                                 NULL);
1144
1145         if (ret != 0) {
1146                 *errcode = ERROR_INVALID_PARAMETER;
1147                 return False;
1148         }
1149
1150         /* force update the database */
1151         print_cache_flush(snum);
1152
1153         /* Send a printer notify message */
1154
1155         printer_name = PRINTERNAME(snum);
1156
1157         message_send_all(conn_tdb_ctx(),MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
1158
1159         return True;
1160 }
1161
1162 /****************************************************************************
1163  resume a queue
1164 ****************************************************************************/
1165 BOOL print_queue_resume(struct current_user *user, int snum, int *errcode)
1166 {
1167         char *printer_name;
1168         int ret;
1169
1170         if (!print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
1171                 *errcode = ERROR_ACCESS_DENIED;
1172                 return False;
1173         }
1174
1175         ret = print_run_command(snum, lp_queueresumecommand(snum), NULL, 
1176                                 NULL);
1177
1178         if (ret != 0) {
1179                 *errcode = ERROR_INVALID_PARAMETER;
1180                 return False;
1181         }
1182
1183         /* force update the database */
1184         print_cache_flush(snum);
1185
1186         /* Send a printer notify message */
1187
1188         printer_name = PRINTERNAME(snum);
1189
1190         message_send_all(conn_tdb_ctx(),MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
1191
1192         return True;
1193 }
1194
1195 /****************************************************************************
1196  purge a queue - implemented by deleting all jobs that we can delete
1197 ****************************************************************************/
1198 BOOL print_queue_purge(struct current_user *user, int snum, int *errcode)
1199 {
1200         print_queue_struct *queue;
1201         print_status_struct status;
1202         char *printer_name;
1203         int njobs, i;
1204
1205         njobs = print_queue_status(snum, &queue, &status);
1206         for (i=0;i<njobs;i++) {
1207                 if (print_access_check(user, snum, PRINTER_ACCESS_ADMINISTER)) {
1208                         print_job_delete1(queue[i].job);
1209                 }
1210         }
1211
1212         print_cache_flush(snum);
1213         safe_free(queue);
1214
1215         /* Send a printer notify message */
1216
1217         printer_name = PRINTERNAME(snum);
1218
1219         message_send_all(conn_tdb_ctx(),MSG_PRINTER_NOTIFY, printer_name, strlen(printer_name) + 1, False);
1220
1221         return True;
1222 }
1223 #undef OLD_NTDOMAIN