s3: Lift the server_messaging_context from print_notify_event_send_messages
[amitay/samba.git] / source3 / printing / notify.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 3.0
4    printing backend routines
5    Copyright (C) Tim Potter, 2002
6    Copyright (C) Gerald Carter,         2002
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "printing.h"
24 #include "librpc/gen_ndr/messaging.h"
25 #include "../librpc/gen_ndr/spoolss.h"
26 #include "nt_printing.h"
27
28 static TALLOC_CTX *send_ctx;
29
30 static unsigned int num_messages;
31
32 static struct notify_queue {
33         struct notify_queue *next, *prev;
34         struct spoolss_notify_msg *msg;
35         struct timeval tv;
36         uint8 *buf;
37         size_t buflen;
38 } *notify_queue_head = NULL;
39
40 static struct tevent_timer *notify_event;
41
42 static bool print_notify_pid_list(const char *printername, TALLOC_CTX *mem_ctx,
43                                   size_t *p_num_pids, pid_t **pp_pid_list);
44
45 static bool create_send_ctx(void)
46 {
47         if (!send_ctx)
48                 send_ctx = talloc_init("print notify queue");
49
50         if (!send_ctx)
51                 return False;
52
53         return True;
54 }
55
56 /****************************************************************************
57  Turn a queue name into a snum.
58 ****************************************************************************/
59
60 int print_queue_snum(const char *qname)
61 {
62         int snum = lp_servicenumber(qname);
63         if (snum == -1 || !lp_print_ok(snum))
64                 return -1;
65         return snum;
66 }
67
68 /*******************************************************************
69  Used to decide if we need a short select timeout.
70 *******************************************************************/
71
72 static bool print_notify_messages_pending(void)
73 {
74         return (notify_queue_head != NULL);
75 }
76
77 /*******************************************************************
78  Flatten data into a message.
79 *******************************************************************/
80
81 static bool flatten_message(struct notify_queue *q)
82 {
83         struct spoolss_notify_msg *msg = q->msg;
84         uint8 *buf = NULL;
85         size_t buflen = 0, len;
86
87 again:
88         len = 0;
89
90         /* Pack header */
91
92         len += tdb_pack(buf + len, buflen - len, "f", msg->printer);
93
94         len += tdb_pack(buf + len, buflen - len, "ddddddd",
95                         (uint32)q->tv.tv_sec, (uint32)q->tv.tv_usec,
96                         msg->type, msg->field, msg->id, msg->len, msg->flags);
97
98         /* Pack data */
99
100         if (msg->len == 0)
101                 len += tdb_pack(buf + len, buflen - len, "dd",
102                                 msg->notify.value[0], msg->notify.value[1]);
103         else
104                 len += tdb_pack(buf + len, buflen - len, "B",
105                                 msg->len, msg->notify.data);
106
107         if (buflen != len) {
108                 buf = (uint8 *)TALLOC_REALLOC(send_ctx, buf, len);
109                 if (!buf)
110                         return False;
111                 buflen = len;
112                 goto again;
113         }
114
115         q->buf = buf;
116         q->buflen = buflen;
117
118         return True;
119 }
120
121 /*******************************************************************
122  Send the batched messages - on a per-printer basis.
123 *******************************************************************/
124
125 static void print_notify_send_messages_to_printer(struct messaging_context *msg_ctx,
126                                                   const char *printer,
127                                                   unsigned int timeout)
128 {
129         char *buf;
130         struct notify_queue *pq, *pq_next;
131         size_t msg_count = 0, offset = 0;
132         size_t num_pids = 0;
133         size_t i;
134         pid_t *pid_list = NULL;
135         struct timeval end_time = timeval_zero();
136
137         /* Count the space needed to send the messages. */
138         for (pq = notify_queue_head; pq; pq = pq->next) {
139                 if (strequal(printer, pq->msg->printer)) {
140                         if (!flatten_message(pq)) {
141                                 DEBUG(0,("print_notify_send_messages: Out of memory\n"));
142                                 talloc_free_children(send_ctx);
143                                 num_messages = 0;
144                                 return;
145                         }
146                         offset += (pq->buflen + 4);
147                         msg_count++;
148                 }       
149         }
150         offset += 4; /* For count. */
151
152         buf = (char *)TALLOC(send_ctx, offset);
153         if (!buf) {
154                 DEBUG(0,("print_notify_send_messages: Out of memory\n"));
155                 talloc_free_children(send_ctx);
156                 num_messages = 0;
157                 return;
158         }
159
160         offset = 0;
161         SIVAL(buf,offset,msg_count);
162         offset += 4;
163         for (pq = notify_queue_head; pq; pq = pq_next) {
164                 pq_next = pq->next;
165
166                 if (strequal(printer, pq->msg->printer)) {
167                         SIVAL(buf,offset,pq->buflen);
168                         offset += 4;
169                         memcpy(buf + offset, pq->buf, pq->buflen);
170                         offset += pq->buflen;
171
172                         /* Remove from list. */
173                         DLIST_REMOVE(notify_queue_head, pq);
174                 }
175         }
176
177         DEBUG(5, ("print_notify_send_messages_to_printer: sending %lu print notify message%s to printer %s\n", 
178                   (unsigned long)msg_count, msg_count != 1 ? "s" : "", printer));
179
180         /*
181          * Get the list of PID's to send to.
182          */
183
184         if (!print_notify_pid_list(printer, send_ctx, &num_pids, &pid_list))
185                 return;
186
187         if (timeout != 0) {
188                 end_time = timeval_current_ofs(timeout, 0);
189         }
190
191         for (i = 0; i < num_pids; i++) {
192                 messaging_send_buf(msg_ctx,
193                                    pid_to_procid(pid_list[i]),
194                                    MSG_PRINTER_NOTIFY2 | MSG_FLAG_LOWPRIORITY,
195                                    (uint8 *)buf, offset);
196
197                 if ((timeout != 0) && timeval_expired(&end_time)) {
198                         break;
199                 }
200         }
201 }
202
203 /*******************************************************************
204  Actually send the batched messages.
205 *******************************************************************/
206
207 void print_notify_send_messages(struct messaging_context *msg_ctx,
208                                 unsigned int timeout)
209 {
210         if (!print_notify_messages_pending())
211                 return;
212
213         if (!create_send_ctx())
214                 return;
215
216         while (print_notify_messages_pending())
217                 print_notify_send_messages_to_printer(
218                         msg_ctx, notify_queue_head->msg->printer, timeout);
219
220         talloc_free_children(send_ctx);
221         num_messages = 0;
222 }
223
224 /*******************************************************************
225  Event handler to send the messages.
226 *******************************************************************/
227
228 static void print_notify_event_send_messages(struct tevent_context *event_ctx,
229                                              struct tevent_timer *te,
230                                              struct timeval now,
231                                              void *private_data)
232 {
233         struct messaging_context *msg_ctx = talloc_get_type_abort(
234                 private_data, struct messaging_context);
235         /* Remove this timed event handler. */
236         TALLOC_FREE(notify_event);
237
238         change_to_root_user();
239         print_notify_send_messages(msg_ctx, 0);
240 }
241
242 /**********************************************************************
243  deep copy a SPOOLSS_NOTIFY_MSG structure using a TALLOC_CTX
244  *********************************************************************/
245  
246 static bool copy_notify2_msg( SPOOLSS_NOTIFY_MSG *to, SPOOLSS_NOTIFY_MSG *from )
247 {
248
249         if ( !to || !from )
250                 return False;
251         
252         memcpy( to, from, sizeof(SPOOLSS_NOTIFY_MSG) );
253         
254         if ( from->len ) {
255                 to->notify.data = (char *)TALLOC_MEMDUP(send_ctx, from->notify.data, from->len );
256                 if ( !to->notify.data ) {
257                         DEBUG(0,("copy_notify2_msg: TALLOC_MEMDUP() of size [%d] failed!\n", from->len ));
258                         return False;
259                 }
260         }
261         
262
263         return True;
264 }
265
266 /*******************************************************************
267  Batch up print notify messages.
268 *******************************************************************/
269
270 static void send_spoolss_notify2_msg(SPOOLSS_NOTIFY_MSG *msg)
271 {
272         struct notify_queue *pnqueue, *tmp_ptr;
273
274         /*
275          * Ensure we only have one job total_bytes and job total_pages for
276          * each job. There is no point in sending multiple messages that match
277          * as they will just cause flickering updates in the client.
278          */
279
280         if ((num_messages < 100) && (msg->type == JOB_NOTIFY_TYPE) 
281                 && (msg->field == JOB_NOTIFY_FIELD_TOTAL_BYTES
282                     || msg->field == JOB_NOTIFY_FIELD_TOTAL_PAGES ))
283         {
284
285                 for (tmp_ptr = notify_queue_head; tmp_ptr; tmp_ptr = tmp_ptr->next) 
286                 {
287                         if (tmp_ptr->msg->type == msg->type &&
288                                         tmp_ptr->msg->field == msg->field &&
289                                         tmp_ptr->msg->id == msg->id &&
290                                         tmp_ptr->msg->flags == msg->flags &&
291                                         strequal(tmp_ptr->msg->printer, msg->printer)) {
292
293                                 DEBUG(5,("send_spoolss_notify2_msg: replacing message 0x%02x/0x%02x for "
294                                          "printer %s in notify_queue\n", msg->type, msg->field, msg->printer));
295
296                                 tmp_ptr->msg = msg;
297                                 return;
298                         }
299                 }
300         }
301
302         /* Store the message on the pending queue. */
303
304         pnqueue = TALLOC_P(send_ctx, struct notify_queue);
305         if (!pnqueue) {
306                 DEBUG(0,("send_spoolss_notify2_msg: Out of memory.\n"));
307                 return;
308         }
309
310         /* allocate a new msg structure and copy the fields */
311         
312         if ( !(pnqueue->msg = TALLOC_P(send_ctx, SPOOLSS_NOTIFY_MSG)) ) {
313                 DEBUG(0,("send_spoolss_notify2_msg: talloc() of size [%lu] failed!\n", 
314                         (unsigned long)sizeof(SPOOLSS_NOTIFY_MSG)));
315                 return;
316         }
317         copy_notify2_msg(pnqueue->msg, msg);
318         GetTimeOfDay(&pnqueue->tv);
319         pnqueue->buf = NULL;
320         pnqueue->buflen = 0;
321
322         DEBUG(5, ("send_spoolss_notify2_msg: appending message 0x%02x/0x%02x for printer %s \
323 to notify_queue_head\n", msg->type, msg->field, msg->printer));
324
325         /*
326          * Note we add to the end of the list to ensure
327          * the messages are sent in the order they were received. JRA.
328          */
329
330         DLIST_ADD_END(notify_queue_head, pnqueue, struct notify_queue *);
331         num_messages++;
332
333         if ((notify_event == NULL) && (server_event_context() != NULL)) {
334                 /* Add an event for 1 second's time to send this queue. */
335                 notify_event = tevent_add_timer(server_event_context(), NULL,
336                                         timeval_current_ofs(1,0),
337                                         print_notify_event_send_messages,
338                                         server_messaging_context());
339         }
340
341 }
342
343 static void send_notify_field_values(const char *sharename, uint32 type,
344                                      uint32 field, uint32 id, uint32 value1, 
345                                      uint32 value2, uint32 flags)
346 {
347         struct spoolss_notify_msg *msg;
348
349         if (lp_disable_spoolss())
350                 return;
351
352         if (!create_send_ctx())
353                 return;
354
355         msg = TALLOC_P(send_ctx, struct spoolss_notify_msg);
356         if (!msg)
357                 return;
358
359         ZERO_STRUCTP(msg);
360
361         fstrcpy(msg->printer, sharename);
362         msg->type = type;
363         msg->field = field;
364         msg->id = id;
365         msg->notify.value[0] = value1;
366         msg->notify.value[1] = value2;
367         msg->flags = flags;
368
369         send_spoolss_notify2_msg(msg);
370 }
371
372 static void send_notify_field_buffer(const char *sharename, uint32 type,
373                                      uint32 field, uint32 id, uint32 len,
374                                      const char *buffer)
375 {
376         struct spoolss_notify_msg *msg;
377
378         if (lp_disable_spoolss())
379                 return;
380
381         if (!create_send_ctx())
382                 return;
383
384         msg = TALLOC_P(send_ctx, struct spoolss_notify_msg);
385         if (!msg)
386                 return;
387
388         ZERO_STRUCTP(msg);
389
390         fstrcpy(msg->printer, sharename);
391         msg->type = type;
392         msg->field = field;
393         msg->id = id;
394         msg->len = len;
395         msg->notify.data = CONST_DISCARD(char *,buffer);
396
397         send_spoolss_notify2_msg(msg);
398 }
399
400 /* Send a message that the printer status has changed */
401
402 void notify_printer_status_byname(const char *sharename, uint32 status)
403 {
404         /* Printer status stored in value1 */
405
406         int snum = print_queue_snum(sharename);
407
408         send_notify_field_values(sharename, PRINTER_NOTIFY_TYPE, 
409                                  PRINTER_NOTIFY_FIELD_STATUS, snum,
410                                  status, 0, 0);
411 }
412
413 void notify_printer_status(int snum, uint32 status)
414 {
415         const char *sharename = lp_servicename(snum);
416
417         if (sharename)
418                 notify_printer_status_byname(sharename, status);
419 }
420
421 void notify_job_status_byname(const char *sharename, uint32 jobid, uint32 status,
422                               uint32 flags)
423 {
424         /* Job id stored in id field, status in value1 */
425
426         send_notify_field_values(sharename, JOB_NOTIFY_TYPE,
427                                  JOB_NOTIFY_FIELD_STATUS, jobid,
428                                  status, 0, flags);
429 }
430
431 void notify_job_status(const char *sharename, uint32 jobid, uint32 status)
432 {
433         notify_job_status_byname(sharename, jobid, status, 0);
434 }
435
436 void notify_job_total_bytes(const char *sharename, uint32 jobid,
437                             uint32 size)
438 {
439         /* Job id stored in id field, status in value1 */
440
441         send_notify_field_values(sharename, JOB_NOTIFY_TYPE,
442                                  JOB_NOTIFY_FIELD_TOTAL_BYTES, jobid,
443                                  size, 0, 0);
444 }
445
446 void notify_job_total_pages(const char *sharename, uint32 jobid,
447                             uint32 pages)
448 {
449         /* Job id stored in id field, status in value1 */
450
451         send_notify_field_values(sharename, JOB_NOTIFY_TYPE,
452                                  JOB_NOTIFY_FIELD_TOTAL_PAGES, jobid,
453                                  pages, 0, 0);
454 }
455
456 void notify_job_username(const char *sharename, uint32 jobid, char *name)
457 {
458         send_notify_field_buffer(
459                 sharename, JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME,
460                 jobid, strlen(name) + 1, name);
461 }
462
463 void notify_job_name(const char *sharename, uint32 jobid, char *name)
464 {
465         send_notify_field_buffer(
466                 sharename, JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT,
467                 jobid, strlen(name) + 1, name);
468 }
469
470 void notify_job_submitted(const char *sharename, uint32 jobid,
471                           time_t submitted)
472 {
473         send_notify_field_buffer(
474                 sharename, JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED,
475                 jobid, sizeof(submitted), (char *)&submitted);
476 }
477
478 void notify_printer_driver(int snum, const char *driver_name)
479 {
480         const char *sharename = lp_servicename(snum);
481
482         send_notify_field_buffer(
483                 sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME,
484                 snum, strlen(driver_name) + 1, driver_name);
485 }
486
487 void notify_printer_comment(int snum, const char *comment)
488 {
489         const char *sharename = lp_servicename(snum);
490
491         send_notify_field_buffer(
492                 sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT,
493                 snum, strlen(comment) + 1, comment);
494 }
495
496 void notify_printer_sharename(int snum, const char *share_name)
497 {
498         const char *sharename = lp_servicename(snum);
499
500         send_notify_field_buffer(
501                 sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME,
502                 snum, strlen(share_name) + 1, share_name);
503 }
504
505 void notify_printer_printername(int snum, const char *printername)
506 {
507         const char *sharename = lp_servicename(snum);
508
509         send_notify_field_buffer(
510                 sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME,
511                 snum, strlen(printername) + 1, printername);
512 }
513
514 void notify_printer_port(int snum, const char *port_name)
515 {
516         const char *sharename = lp_servicename(snum);
517
518         send_notify_field_buffer(
519                 sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME,
520                 snum, strlen(port_name) + 1, port_name);
521 }
522
523 void notify_printer_location(int snum, const char *location)
524 {
525         const char *sharename = lp_servicename(snum);
526
527         send_notify_field_buffer(
528                 sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION,
529                 snum, strlen(location) + 1, location);
530 }
531
532 void notify_printer_byname( const char *printername, uint32 change, const char *value )
533 {
534         int snum = print_queue_snum(printername);
535         int type = PRINTER_NOTIFY_TYPE;
536         
537         if ( snum == -1 )
538                 return;
539                 
540         send_notify_field_buffer( printername, type, change, snum, strlen(value)+1, value );
541
542
543
544 /****************************************************************************
545  Return a malloced list of pid_t's that are interested in getting update
546  messages on this print queue. Used in printing/notify to send the messages.
547 ****************************************************************************/
548
549 static bool print_notify_pid_list(const char *printername, TALLOC_CTX *mem_ctx,
550                                   size_t *p_num_pids, pid_t **pp_pid_list)
551 {
552         struct tdb_print_db *pdb = NULL;
553         TDB_CONTEXT *tdb = NULL;
554         TDB_DATA data;
555         bool ret = True;
556         size_t i, num_pids, offset;
557         pid_t *pid_list;
558
559         *p_num_pids = 0;
560         *pp_pid_list = NULL;
561
562         pdb = get_print_db_byname(printername);
563         if (!pdb)
564                 return False;
565         tdb = pdb->tdb;
566
567         if (tdb_read_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) == -1) {
568                 DEBUG(0,("print_notify_pid_list: Failed to lock printer %s database\n",
569                                         printername));
570                 if (pdb)
571                         release_print_db(pdb);
572                 return False;
573         }
574
575         data = get_printer_notify_pid_list( tdb, printername, True );
576
577         if (!data.dptr) {
578                 ret = True;
579                 goto done;
580         }
581
582         num_pids = data.dsize / 8;
583
584         if (num_pids) {
585                 if ((pid_list = TALLOC_ARRAY(mem_ctx, pid_t, num_pids)) == NULL) {
586                         ret = False;
587                         goto done;
588                 }
589         } else {
590                 pid_list = NULL;
591         }
592
593         for( i = 0, offset = 0; i < num_pids; offset += 8, i++)
594                 pid_list[i] = (pid_t)IVAL(data.dptr, offset);
595
596         *pp_pid_list = pid_list;
597         *p_num_pids = num_pids;
598
599         ret = True;
600
601   done:
602
603         tdb_read_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY);
604         if (pdb)
605                 release_print_db(pdb);
606         SAFE_FREE(data.dptr);
607         return ret;
608 }