From 8daa83a594a2e98f39d764422bfbdbc62c9efd44 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 19:20:00 +0200 Subject: Adding upstream version 2:4.20.0+dfsg. Signed-off-by: Daniel Baumann --- source3/printing/load.c | 109 + source3/printing/load.h | 28 + source3/printing/lpq_parse.c | 1164 ++++++++ source3/printing/notify.c | 693 +++++ source3/printing/notify.h | 87 + source3/printing/nt_printing.c | 2419 +++++++++++++++++ source3/printing/nt_printing_ads.c | 908 +++++++ source3/printing/nt_printing_migrate.c | 386 +++ source3/printing/nt_printing_migrate.h | 47 + source3/printing/nt_printing_migrate_internal.c | 272 ++ source3/printing/nt_printing_migrate_internal.h | 26 + source3/printing/nt_printing_os2.c | 167 ++ source3/printing/nt_printing_os2.h | 22 + source3/printing/nt_printing_tdb.c | 498 ++++ source3/printing/nt_printing_tdb.h | 28 + source3/printing/pcap.c | 213 ++ source3/printing/pcap.h | 69 + source3/printing/print_aix.c | 140 + source3/printing/print_cups.c | 1749 ++++++++++++ source3/printing/print_generic.c | 358 +++ source3/printing/print_iprint.c | 1367 ++++++++++ source3/printing/print_standard.c | 157 ++ source3/printing/print_svid.c | 148 + source3/printing/printer_list.c | 460 ++++ source3/printing/printer_list.h | 105 + source3/printing/printing.c | 3266 +++++++++++++++++++++++ source3/printing/printing_db.c | 228 ++ source3/printing/printspoolss.c | 406 +++ source3/printing/queue_process.c | 451 ++++ source3/printing/queue_process.h | 44 + source3/printing/rap_jobid.c | 164 ++ source3/printing/rap_jobid.h | 29 + source3/printing/samba-bgqd.c | 359 +++ source3/printing/tests/README.vlp | 19 + source3/printing/tests/vlp.c | 445 +++ 35 files changed, 17031 insertions(+) create mode 100644 source3/printing/load.c create mode 100644 source3/printing/load.h create mode 100644 source3/printing/lpq_parse.c create mode 100644 source3/printing/notify.c create mode 100644 source3/printing/notify.h create mode 100644 source3/printing/nt_printing.c create mode 100644 source3/printing/nt_printing_ads.c create mode 100644 source3/printing/nt_printing_migrate.c create mode 100644 source3/printing/nt_printing_migrate.h create mode 100644 source3/printing/nt_printing_migrate_internal.c create mode 100644 source3/printing/nt_printing_migrate_internal.h create mode 100644 source3/printing/nt_printing_os2.c create mode 100644 source3/printing/nt_printing_os2.h create mode 100644 source3/printing/nt_printing_tdb.c create mode 100644 source3/printing/nt_printing_tdb.h create mode 100644 source3/printing/pcap.c create mode 100644 source3/printing/pcap.h create mode 100644 source3/printing/print_aix.c create mode 100644 source3/printing/print_cups.c create mode 100644 source3/printing/print_generic.c create mode 100644 source3/printing/print_iprint.c create mode 100644 source3/printing/print_standard.c create mode 100644 source3/printing/print_svid.c create mode 100644 source3/printing/printer_list.c create mode 100644 source3/printing/printer_list.h create mode 100644 source3/printing/printing.c create mode 100644 source3/printing/printing_db.c create mode 100644 source3/printing/printspoolss.c create mode 100644 source3/printing/queue_process.c create mode 100644 source3/printing/queue_process.h create mode 100644 source3/printing/rap_jobid.c create mode 100644 source3/printing/rap_jobid.h create mode 100644 source3/printing/samba-bgqd.c create mode 100644 source3/printing/tests/README.vlp create mode 100644 source3/printing/tests/vlp.c (limited to 'source3/printing') diff --git a/source3/printing/load.c b/source3/printing/load.c new file mode 100644 index 0000000..ea5154d --- /dev/null +++ b/source3/printing/load.c @@ -0,0 +1,109 @@ +/* + Unix SMB/CIFS implementation. + load printer lists + Copyright (C) Andrew Tridgell 1992-2000 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "printing/pcap.h" +#include "printing/printer_list.h" +#include "printing/load.h" +#include "lib/param/loadparm.h" + +/*************************************************************************** +auto-load some homes and printer services +***************************************************************************/ +static void add_auto_printers(void) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *p; + int pnum = lp_servicenumber(PRINTERS_NAME); + char *str; + char *saveptr; + char *auto_serv = NULL; + + if (pnum < 0) + if (process_registry_service(PRINTERS_NAME)) + pnum = lp_servicenumber(PRINTERS_NAME); + + if (pnum < 0) + return; + + auto_serv = lp_auto_services(talloc_tos(), lp_sub); + str = SMB_STRDUP(auto_serv); + TALLOC_FREE(auto_serv); + if (str == NULL) { + return; + } + + for (p = strtok_r(str, LIST_SEP, &saveptr); p; + p = strtok_r(NULL, LIST_SEP, &saveptr)) { + if (lp_servicenumber(p) >= 0) + continue; + + if (printer_list_printername_exists(p)) + lp_add_printer(p, pnum); + } + + SAFE_FREE(str); +} + +/*************************************************************************** +load automatic printer services from pre-populated pcap cache +***************************************************************************/ +void load_printers(void) +{ + NTSTATUS status; + + if (!pcap_cache_loaded(NULL)) { + return; + } + + add_auto_printers(); + + if (!lp_load_printers()) { + return; + } + + /* + * Do not add printers from pcap, if we don't have a [printers] share. + */ + if (lp_servicenumber(PRINTERS_NAME) < 0) { + return; + } + + status = printer_list_read_run_fn(lp_add_one_printer, NULL); + if (!NT_STATUS_IS_OK(status)) { + DBG_NOTICE("printer_list_read_run_fn failed: %s\n", + nt_errstr(status)); + } +} + +bool pcap_cache_loaded(time_t *_last_change) +{ + NTSTATUS status; + time_t last; + + status = printer_list_get_last_refresh(&last); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + if (_last_change != NULL) { + *_last_change = last; + } + return true; +} diff --git a/source3/printing/load.h b/source3/printing/load.h new file mode 100644 index 0000000..5a37769 --- /dev/null +++ b/source3/printing/load.h @@ -0,0 +1,28 @@ +/* + Unix SMB/CIFS implementation. + load printer lists + Copyright (C) Andrew Tridgell 1992-2000 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef _PRINTING_LOAD_H_ +#define _PRINTING_LOAD_H_ + +/* The following definitions come from printing/load.c */ + +bool pcap_cache_loaded(time_t *_last_change); +void load_printers(void); + +#endif /* _PRINTING_LOAD_H_ */ diff --git a/source3/printing/lpq_parse.c b/source3/printing/lpq_parse.c new file mode 100644 index 0000000..8351402 --- /dev/null +++ b/source3/printing/lpq_parse.c @@ -0,0 +1,1164 @@ +/* + Unix SMB/CIFS implementation. + lpq parsing routines + Copyright (C) Andrew Tridgell 2000 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "printing.h" +#include "lib/util/string_wrappers.h" + +static const char *Months[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Err"}; + + +/******************************************************************* + Process time fields +********************************************************************/ + +static time_t EntryTime(char *tok[], int ptr, int count, int minimum) +{ + time_t jobtime,jobtime1; + + jobtime = time(NULL); /* default case: take current time */ + if (count >= minimum) { + struct tm *t; + int i, day, hour, min, sec; + + for (i=0; i<13; i++) { + if (!strncmp(tok[ptr], Months[i],3)) { + break; /* Find month */ + } + } + + if (i<12) { + fstring c; + t = localtime(&jobtime); + if (!t) { + return (time_t)-1; + } + day = atoi(tok[ptr+1]); + fstrcpy(c,tok[ptr+2]); + *(c+2)=0; + hour = atoi(c); + *(c+5)=0; + min = atoi(c+3); + if(*(c+6) != 0) { + sec = atoi(c+6); + } else { + sec=0; + } + + if ((t->tm_mon < i)|| ((t->tm_mon == i)&& + ((t->tm_mday < day)|| + ((t->tm_mday == day)&& + (t->tm_hour*60+t->tm_min < hour*60+min))))) { + t->tm_year--; /* last year's print job */ + } + + t->tm_mon = i; + t->tm_mday = day; + t->tm_hour = hour; + t->tm_min = min; + t->tm_sec = sec; + jobtime1 = mktime(t); + if (jobtime1 != (time_t)-1) { + jobtime = jobtime1; + } + } + } + return jobtime; +} + +/**************************************************************************** +parse a lpq line + +here is an example of lpq output under bsd + +Warning: no daemon present +Rank Owner Job Files Total Size +1st tridge 148 README 8096 bytes + +here is an example of lpq output under osf/1 + +Warning: no daemon present +Rank Pri Owner Job Files Total Size +1st 0 tridge 148 README 8096 bytes + + + June 30, 1998. +Modified to handle file names with spaces, like the parse_lpq_lprng code +further below. +****************************************************************************/ + +static bool parse_lpq_bsd(char *line,print_queue_struct *buf,bool first) +{ +#ifdef OSF1 +#define RANKTOK 0 +#define PRIOTOK 1 +#define USERTOK 2 +#define JOBTOK 3 +#define FILETOK 4 +#define TOTALTOK (count - 2) +#define NTOK 6 +#define MAXTOK 128 +#else /* OSF1 */ +#define RANKTOK 0 +#define USERTOK 1 +#define JOBTOK 2 +#define FILETOK 3 +#define TOTALTOK (count - 2) +#define NTOK 5 +#define MAXTOK 128 +#endif /* OSF1 */ + + char *tok[MAXTOK]; + int count = 0; + TALLOC_CTX *ctx = talloc_tos(); + char *line2 = NULL; + char *saveptr; + + line2 = talloc_strdup(ctx, line); + if (!line2) { + return false; + } + +#ifdef OSF1 + { + size_t length; + length = strlen(line2); + if (line2[length-3] == ':') { + return False; + } + } +#endif /* OSF1 */ + + /* FIXME: Use next_token_talloc rather than strtok! */ + tok[0] = strtok_r(line2," \t", &saveptr); + count++; + + while ((count < MAXTOK) + && ((tok[count] = strtok_r(NULL, " \t", &saveptr)) != NULL)) { + count++; + } + + /* we must get at least NTOK tokens */ + if (count < NTOK) { + return False; + } + + /* the Job and Total columns must be integer */ + if (!isdigit((int)*tok[JOBTOK]) || !isdigit((int)*tok[TOTALTOK])) { + return False; + } + + buf->sysjob = atoi(tok[JOBTOK]); + buf->size = atoi(tok[TOTALTOK]); + buf->status = strequal(tok[RANKTOK],"active")?LPQ_PRINTING:LPQ_QUEUED; + buf->time = time(NULL); + fstrcpy(buf->fs_user,tok[USERTOK]); + fstrcpy(buf->fs_file,tok[FILETOK]); + + if ((FILETOK + 1) != TOTALTOK) { + int i; + + for (i = (FILETOK + 1); i < TOTALTOK; i++) { + /* FIXME: Using fstrcat rather than other means is a bit + * inefficient; this might be a problem for enormous queues with + * many fields. */ + fstrcat(buf->fs_file, " "); + fstrcat(buf->fs_file, tok[i]); + } + /* Ensure null termination. */ + buf->fs_file[sizeof(buf->fs_file)-1] = '\0'; + } + +#ifdef PRIOTOK + buf->priority = atoi(tok[PRIOTOK]); +#else + buf->priority = 1; +#endif + return True; +} + +/* + +LPRng_time modifies the current date by inserting the hour and minute from +the lpq output. The lpq time looks like "23:15:07" + + June 30, 1998. +Modified to work with the re-written parse_lpq_lprng routine. + + Dec 17,1999 +Modified to work with lprng 3.16 +With lprng 3.16 The lpq time looks like + "23:15:07" + "23:15:07.100" + "1999-12-16-23:15:07" + "1999-12-16-23:15:07.100" + +*/ +static time_t LPRng_time(char *time_string) +{ + time_t jobtime; + struct tm *t; + + jobtime = time(NULL); /* default case: take current time */ + t = localtime(&jobtime); + if (!t) { + return (time_t)-1; + } + + if ( atoi(time_string) < 24 ){ + if (strlen(time_string) < 7) { + return (time_t)-1; + } + t->tm_hour = atoi(time_string); + t->tm_min = atoi(time_string+3); + t->tm_sec = atoi(time_string+6); + } else { + if (strlen(time_string) < 18) { + return (time_t)-1; + } + t->tm_year = atoi(time_string)-1900; + t->tm_mon = atoi(time_string+5)-1; + t->tm_mday = atoi(time_string+8); + t->tm_hour = atoi(time_string+11); + t->tm_min = atoi(time_string+14); + t->tm_sec = atoi(time_string+17); + } + jobtime = mktime(t); + + return jobtime; +} + +/**************************************************************************** + parse a lprng lpq line + June 30, 1998. + Re-wrote this to handle file names with spaces, multiple file names on one + lpq line, etc; + +****************************************************************************/ + +static bool parse_lpq_lprng(char *line,print_queue_struct *buf,bool first) +{ +#define LPRNG_RANKTOK 0 +#define LPRNG_USERTOK 1 +#define LPRNG_PRIOTOK 2 +#define LPRNG_JOBTOK 3 +#define LPRNG_FILETOK 4 +#define LPRNG_TOTALTOK (num_tok - 2) +#define LPRNG_TIMETOK (num_tok - 1) +#define LPRNG_NTOK 7 +#define LPRNG_MAXTOK 128 /* PFMA just to keep us from running away. */ + + char *tokarr[LPRNG_MAXTOK]; + const char *cptr; + char *ptr; + int num_tok = 0; + TALLOC_CTX *frame = talloc_stackframe(); + + cptr = line; + while((num_tok < LPRNG_MAXTOK) && next_token_talloc(frame, &cptr, + &tokarr[num_tok], " \t")) { + num_tok++; + } + + /* We must get at least LPRNG_NTOK tokens. */ + if (num_tok < LPRNG_NTOK) { + TALLOC_FREE(frame); + return False; + } + + if (!isdigit((int)*tokarr[LPRNG_JOBTOK]) || !isdigit((int)*tokarr[LPRNG_TOTALTOK])) { + TALLOC_FREE(frame); + return False; + } + + buf->sysjob = atoi(tokarr[LPRNG_JOBTOK]); + buf->size = atoi(tokarr[LPRNG_TOTALTOK]); + + if (strequal(tokarr[LPRNG_RANKTOK],"active")) { + buf->status = LPQ_PRINTING; + } else if (strequal(tokarr[LPRNG_RANKTOK],"done")) { + buf->status = LPQ_PRINTED; + } else if (isdigit((int)*tokarr[LPRNG_RANKTOK])) { + buf->status = LPQ_QUEUED; + } else { + buf->status = LPQ_PAUSED; + } + + buf->priority = *tokarr[LPRNG_PRIOTOK] -'A'; + + buf->time = LPRng_time(tokarr[LPRNG_TIMETOK]); + + fstrcpy(buf->fs_user,tokarr[LPRNG_USERTOK]); + + /* The '@hostname' prevents windows from displaying the printing icon + * for the current user on the taskbar. Plop in a null. + */ + + if ((ptr = strchr_m(buf->fs_user,'@')) != NULL) { + *ptr = '\0'; + } + + fstrcpy(buf->fs_file,tokarr[LPRNG_FILETOK]); + + if ((LPRNG_FILETOK + 1) != LPRNG_TOTALTOK) { + int i; + + for (i = (LPRNG_FILETOK + 1); i < LPRNG_TOTALTOK; i++) { + /* FIXME: Using fstrcat rather than other means is a bit + * inefficient; this might be a problem for enormous queues with + * many fields. */ + fstrcat(buf->fs_file, " "); + fstrcat(buf->fs_file, tokarr[i]); + } + /* Ensure null termination. */ + buf->fs_file[sizeof(buf->fs_file)-1] = '\0'; + } + + TALLOC_FREE(frame); + return True; +} + +/******************************************************************* +parse lpq on an aix system + +Queue Dev Status Job Files User PP % Blks Cp Rnk +------- ----- --------- --- ------------------ ---------- ---- -- ----- --- --- +laser laser READY +laser laser RUNNING 537 6297doc.A kvintus@IE 0 10 2445 1 1 + QUEUED 538 C.ps root@IEDVB 124 1 2 + QUEUED 539 E.ps root@IEDVB 28 1 3 + QUEUED 540 L.ps root@IEDVB 172 1 4 + QUEUED 541 P.ps root@IEDVB 22 1 5 +********************************************************************/ + +static bool parse_lpq_aix(char *line,print_queue_struct *buf,bool first) +{ + char *tok[11]; + int count=0; + const char *cline = line; + TALLOC_CTX *frame = talloc_stackframe(); + + /* handle the case of "(standard input)" as a filename */ + string_sub(line,"standard input","STDIN",0); + all_string_sub(line,"(","\"",0); + all_string_sub(line,")","\"",0); + + for (count=0; count<10 && + next_token_talloc(frame,&cline,&tok[count],NULL); count++) { + ; + } + + /* we must get 6 tokens */ + if (count < 10) { + if ((count == 7) && ((strcmp(tok[0],"QUEUED") == 0) || (strcmp(tok[0],"HELD") == 0))) { + /* the 2nd and 5th columns must be integer */ + if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[4])) { + TALLOC_FREE(frame); + return False; + } + buf->size = atoi(tok[4]) * 1024; + /* if the fname contains a space then use STDIN */ + if (strchr_m(tok[2],' ')) { + tok[2] = talloc_strdup(frame,"STDIN"); + if (!tok[2]) { + TALLOC_FREE(frame); + return false; + } + } + + /* only take the last part of the filename */ + { + char *p = strrchr_m(tok[2],'/'); + if (p) { + tok[2] = p+1; + } + } + + buf->sysjob = atoi(tok[1]); + buf->status = strequal(tok[0],"HELD")?LPQ_PAUSED:LPQ_QUEUED; + buf->priority = 0; + buf->time = time(NULL); + fstrcpy(buf->fs_user,tok[3]); + fstrcpy(buf->fs_file,tok[2]); + } else { + DEBUG(6,("parse_lpq_aix count=%d\n", count)); + TALLOC_FREE(frame); + return False; + } + } else { + /* the 4th and 9th columns must be integer */ + if (!isdigit((int)*tok[3]) || !isdigit((int)*tok[8])) { + TALLOC_FREE(frame); + return False; + } + + buf->size = atoi(tok[8]) * 1024; + /* if the fname contains a space then use STDIN */ + if (strchr_m(tok[4],' ')) { + tok[4] = talloc_strdup(frame,"STDIN"); + if (!tok[4]) { + TALLOC_FREE(frame); + return false; + } + } + + /* only take the last part of the filename */ + { + char *p = strrchr_m(tok[4],'/'); + if (p) { + tok[4] = p+1; + } + } + + buf->sysjob = atoi(tok[3]); + buf->status = strequal(tok[2],"RUNNING")?LPQ_PRINTING:LPQ_QUEUED; + buf->priority = 0; + buf->time = time(NULL); + fstrcpy(buf->fs_user,tok[5]); + fstrcpy(buf->fs_file,tok[4]); + } + + TALLOC_FREE(frame); + return True; +} + +/**************************************************************************** +parse a lpq line +here is an example of lpq output under hpux; note there's no space after -o ! +$> lpstat -oljplus +ljplus-2153 user priority 0 Jan 19 08:14 on ljplus + util.c 125697 bytes + server.c 110712 bytes +ljplus-2154 user priority 0 Jan 19 08:14 from client + (standard input) 7551 bytes +****************************************************************************/ + +static bool parse_lpq_hpux(char *line, print_queue_struct *buf, bool first) +{ + /* must read two lines to process, therefore keep some values static */ + static bool header_line_ok=False, base_prio_reset=False; + static char *jobuser; + static int jobid; + static int jobprio; + static time_t jobtime; + static int jobstat=LPQ_QUEUED; + /* to store minimum priority to print, lpstat command should be invoked + with -p option first, to work */ + static int base_prio; + int count; + char htab = '\011'; + const char *cline = line; + char *tok[12]; + TALLOC_CTX *frame = talloc_stackframe(); + + /* If a line begins with a horizontal TAB, it is a subline type */ + + if (line[0] == htab) { /* subline */ + /* check if it contains the base priority */ + if (!strncmp(line,"\tfence priority : ",18)) { + base_prio=atoi(&line[18]); + DEBUG(4, ("fence priority set at %d\n", base_prio)); + } + + if (!header_line_ok) { + TALLOC_FREE(frame); + return False; /* incorrect header line */ + } + + /* handle the case of "(standard input)" as a filename */ + string_sub(line,"standard input","STDIN",0); + all_string_sub(line,"(","\"",0); + all_string_sub(line,")","\"",0); + + for (count=0; count<2 && + next_token_talloc(frame, &cline, &tok[count],NULL); + count++) { + ; + } + /* we must get 2 tokens */ + if (count < 2) { + TALLOC_FREE(frame); + return False; + } + + /* the 2nd column must be integer */ + if (!isdigit((int)*tok[1])) { + TALLOC_FREE(frame); + return False; + } + + /* if the fname contains a space then use STDIN */ + if (strchr_m(tok[0],' ')) { + tok[0] = talloc_strdup(frame, "STDIN"); + if (!tok[0]) { + TALLOC_FREE(frame); + return false; + } + } + + buf->size = atoi(tok[1]); + fstrcpy(buf->fs_file,tok[0]); + + /* fill things from header line */ + buf->time = jobtime; + buf->sysjob = jobid; + buf->status = jobstat; + buf->priority = jobprio; + if (jobuser) { + fstrcpy(buf->fs_user,jobuser); + } else { + buf->fs_user[0] = '\0'; + } + + TALLOC_FREE(frame); + return True; + } else { /* header line */ + header_line_ok=False; /* reset it */ + if (first) { + if (!base_prio_reset) { + base_prio=0; /* reset it */ + base_prio_reset=True; + } + } else if (base_prio) { + base_prio_reset=False; + } + + /* handle the dash in the job id */ + string_sub(line,"-"," ",0); + + for (count=0; count<12 && + next_token_talloc(frame, &cline, &tok[count],NULL); + count++) { + ; + } + + /* we must get 8 tokens */ + if (count < 8) { + TALLOC_FREE(frame); + return False; + } + + /* first token must be printer name (cannot check ?) */ + /* the 2nd, 5th & 7th column must be integer */ + if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[4]) || !isdigit((int)*tok[6])) { + TALLOC_FREE(frame); + return False; + } + jobid = atoi(tok[1]); + SAFE_FREE(jobuser); + jobuser = SMB_STRDUP(tok[2]); + jobprio = atoi(tok[4]); + + /* process time */ + jobtime=EntryTime(tok, 5, count, 8); + if (jobprio < base_prio) { + jobstat = LPQ_PAUSED; + DEBUG (4, ("job %d is paused: prio %d < %d; jobstat=%d\n", + jobid, jobprio, base_prio, jobstat)); + } else { + jobstat = LPQ_QUEUED; + if ((count >8) && (((strequal(tok[8],"on")) || + ((strequal(tok[8],"from")) && + ((count > 10)&&(strequal(tok[10],"on"))))))) { + jobstat = LPQ_PRINTING; + } + } + + header_line_ok=True; /* information is correct */ + TALLOC_FREE(frame); + return False; /* need subline info to include into queuelist */ + } +} + +/**************************************************************************** +parse a lpstat line + +here is an example of "lpstat -o dcslw" output under sysv + +dcslw-896 tridge 4712 Dec 20 10:30:30 on dcslw +dcslw-897 tridge 4712 Dec 20 10:30:30 being held + +****************************************************************************/ + +static bool parse_lpq_sysv(char *line,print_queue_struct *buf,bool first) +{ + char *tok[9]; + int count=0; + char *p; + const char *cline = line; + TALLOC_CTX *frame = NULL; + + /* + * Handle the dash in the job id, but make sure that we skip over + * the printer name in case we have a dash in that. + * Patch from Dom.Mitchell@palmerharvey.co.uk. + */ + + /* + * Move to the first space. + */ + for (p = line ; !isspace(*p) && *p; p++) { + ; + } + + /* + * Back up until the last '-' character or + * start of line. + */ + for (; (p >= line) && (*p != '-'); p--) { + ; + } + + if((p >= line) && (*p == '-')) { + *p = ' '; + } + + frame = talloc_stackframe(); + for (count=0; count<9 && + next_token_talloc(frame, &cline, &tok[count],NULL); + count++) { + ; + } + + /* we must get 7 tokens */ + if (count < 7) { + TALLOC_FREE(frame); + return False; + } + + /* the 2nd and 4th, 6th columns must be integer */ + if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[3])) { + TALLOC_FREE(frame); + return False; + } + if (!isdigit((int)*tok[5])) { + TALLOC_FREE(frame); + return False; + } + + /* if the user contains a ! then trim the first part of it */ + if ((p=strchr_m(tok[2],'!'))) { + tok[2] = p+1; + } + + buf->sysjob = atoi(tok[1]); + buf->size = atoi(tok[3]); + if (count > 7 && strequal(tok[7],"on")) { + buf->status = LPQ_PRINTING; + } else if (count > 8 && strequal(tok[7],"being") && strequal(tok[8],"held")) { + buf->status = LPQ_PAUSED; + } else { + buf->status = LPQ_QUEUED; + } + buf->priority = 0; + buf->time = EntryTime(tok, 4, count, 7); + fstrcpy(buf->fs_user,tok[2]); + fstrcpy(buf->fs_file,tok[2]); + TALLOC_FREE(frame); + return True; +} + +/**************************************************************************** +parse a lpq line + +here is an example of lpq output under qnx +Spooler: /qnx/spooler, on node 1 +Printer: txt (ready) +0000: root [job #1 ] active 1146 bytes /etc/profile +0001: root [job #2 ] ready 2378 bytes /etc/install +0002: root [job #3 ] ready 1146 bytes -- standard input -- +****************************************************************************/ + +static bool parse_lpq_qnx(char *line,print_queue_struct *buf,bool first) +{ + char *tok[7]; + int count=0; + const char *cline = line; + TALLOC_CTX *frame = NULL; + + DEBUG(4,("antes [%s]\n", line)); + + /* handle the case of "-- standard input --" as a filename */ + string_sub(line,"standard input","STDIN",0); + DEBUG(4,("despues [%s]\n", line)); + all_string_sub(line,"-- ","\"",0); + all_string_sub(line," --","\"",0); + DEBUG(4,("despues 1 [%s]\n", line)); + + string_sub(line,"[job #","",0); + string_sub(line,"]","",0); + DEBUG(4,("despues 2 [%s]\n", line)); + + frame = talloc_stackframe(); + for (count=0; count<7 && + next_token_talloc(frame,&cline,&tok[count],NULL); + count++) { + ; + } + + /* we must get 7 tokens */ + if (count < 7) { + TALLOC_FREE(frame); + return False; + } + + /* the 3rd and 5th columns must be integer */ + if (!isdigit((int)*tok[2]) || !isdigit((int)*tok[4])) { + TALLOC_FREE(frame); + return False; + } + + /* only take the last part of the filename */ + { + char *p = strrchr_m(tok[6],'/'); + if (p) { + tok[6] = p+1; + } + } + + buf->sysjob = atoi(tok[2]); + buf->size = atoi(tok[4]); + buf->status = strequal(tok[3],"active")?LPQ_PRINTING:LPQ_QUEUED; + buf->priority = 0; + buf->time = time(NULL); + fstrcpy(buf->fs_user,tok[1]); + fstrcpy(buf->fs_file,tok[6]); + TALLOC_FREE(frame); + return True; +} + +/**************************************************************************** + parse a lpq line for the plp printing system + Bertrand Wallrich + +redone by tridge. Here is a sample queue: + +Local Printer 'lp2' (fjall): + Printing (started at Jun 15 13:33:58, attempt 1). + Rank Owner Pr Opt Job Host Files Size Date + active tridge X - 6 fjall /etc/hosts 739 Jun 15 13:33 + 3rd tridge X - 7 fjall /etc/hosts 739 Jun 15 13:33 + +****************************************************************************/ + +static bool parse_lpq_plp(char *line,print_queue_struct *buf,bool first) +{ + char *tok[11]; + int count=0; + const char *cline = line; + TALLOC_CTX *frame = talloc_stackframe(); + + /* handle the case of "(standard input)" as a filename */ + string_sub(line,"stdin","STDIN",0); + all_string_sub(line,"(","\"",0); + all_string_sub(line,")","\"",0); + + for (count=0; count<11 && + next_token_talloc(frame,&cline,&tok[count],NULL); + count++) { + ; + } + + /* we must get 11 tokens */ + if (count < 11) { + TALLOC_FREE(frame); + return False; + } + + /* the first must be "active" or begin with an integer */ + if (strcmp(tok[0],"active") && !isdigit((int)tok[0][0])) { + TALLOC_FREE(frame); + return False; + } + + /* the 5th and 8th must be integer */ + if (!isdigit((int)*tok[4]) || !isdigit((int)*tok[7])) { + TALLOC_FREE(frame); + return False; + } + + /* if the fname contains a space then use STDIN */ + if (strchr_m(tok[6],' ')) { + tok[6] = talloc_strdup(frame, "STDIN"); + if (!tok[6]) { + TALLOC_FREE(frame); + return false; + } + } + + /* only take the last part of the filename */ + { + fstring tmp; + char *p = strrchr_m(tok[6],'/'); + if (p) { + size_t len = strlen(tok[6])+1; + fstrcpy(tmp,p+1); + strlcpy(tok[6],tmp, len); + } + } + + buf->sysjob = atoi(tok[4]); + + buf->size = atoi(tok[7]); + if (strchr_m(tok[7],'K')) { + buf->size *= 1024; + } + if (strchr_m(tok[7],'M')) { + buf->size *= 1024*1024; + } + + buf->status = strequal(tok[0],"active")?LPQ_PRINTING:LPQ_QUEUED; + buf->priority = 0; + buf->time = time(NULL); + fstrcpy(buf->fs_user,tok[1]); + fstrcpy(buf->fs_file,tok[6]); + TALLOC_FREE(frame); + return True; +} + +/******************************************************************* +parse lpq on an NT system + + Windows 2000 LPD Server + Printer \\10.0.0.2\NP17PCL (Paused) + +Owner Status Jobname Job-Id Size Pages Priority +---------------------------------------------------------------------------- +root (9.99. Printing /usr/lib/rhs/rhs-pr 3 625 0 1 +root (9.99. Paused /usr/lib/rhs/rhs-pr 4 625 0 1 +jmcd Waiting Re: Samba Open Sour 26 32476 1 1 + +********************************************************************/ + +static bool parse_lpq_nt(char *line,print_queue_struct *buf,bool first) +{ +#define LPRNT_OWNSIZ 11 +#define LPRNT_STATSIZ 9 +#define LPRNT_JOBSIZ 19 +#define LPRNT_IDSIZ 6 +#define LPRNT_SIZSIZ 9 + typedef struct { + char owner[LPRNT_OWNSIZ]; + char space1; + char status[LPRNT_STATSIZ]; + char space2; + char jobname[LPRNT_JOBSIZ]; + char space3; + char jobid[LPRNT_IDSIZ]; + char space4; + char size[LPRNT_SIZSIZ]; + char terminator; + } nt_lpq_line; + + char parse_line_char[sizeof(nt_lpq_line)]; + nt_lpq_line *parse_line = (nt_lpq_line *)parse_line_char; +#define LPRNT_PRINTING "Printing" +#define LPRNT_WAITING "Waiting" +#define LPRNT_PAUSED "Paused" + + memset(parse_line_char, '\0', sizeof(parse_line_char)); + strncpy(parse_line_char, line, sizeof(parse_line_char) -1); + + if (strlen(parse_line_char) != sizeof(parse_line_char) - 1) { + return False; + } + + /* Just want the first word in the owner field - the username */ + if (strchr_m(parse_line->owner, ' ')) { + *(strchr_m(parse_line->owner, ' ')) = '\0'; + } else { + parse_line->space1 = '\0'; + } + + /* Make sure we have an owner */ + if (!strlen(parse_line->owner)) { + return False; + } + + /* Make sure the status is valid */ + parse_line->space2 = '\0'; + trim_char(parse_line->status, '\0', ' '); + if (!strequal(parse_line->status, LPRNT_PRINTING) && + !strequal(parse_line->status, LPRNT_PAUSED) && + !strequal(parse_line->status, LPRNT_WAITING)) { + return False; + } + + parse_line->space3 = '\0'; + trim_char(parse_line->jobname, '\0', ' '); + + buf->sysjob = atoi(parse_line->jobid); + buf->priority = 0; + buf->size = atoi(parse_line->size); + buf->time = time(NULL); + fstrcpy(buf->fs_user, parse_line->owner); + fstrcpy(buf->fs_file, parse_line->jobname); + if (strequal(parse_line->status, LPRNT_PRINTING)) { + buf->status = LPQ_PRINTING; + } else if (strequal(parse_line->status, LPRNT_PAUSED)) { + buf->status = LPQ_PAUSED; + } else { + buf->status = LPQ_QUEUED; + } + + return True; +} + +/******************************************************************* +parse lpq on an OS2 system + +JobID File Name Rank Size Status Comment +----- --------------- ------ -------- ------------ ------------ + 3 Control 1 68 Queued root@psflinu + 4 /etc/motd 2 11666 Queued root@psflinu + +********************************************************************/ + +static bool parse_lpq_os2(char *line,print_queue_struct *buf,bool first) +{ +#define LPROS2_IDSIZ 5 +#define LPROS2_JOBSIZ 15 +#define LPROS2_SIZSIZ 8 +#define LPROS2_STATSIZ 12 +#define LPROS2_OWNSIZ 12 + typedef struct { + char jobid[LPROS2_IDSIZ]; + char space1[2]; + char jobname[LPROS2_JOBSIZ]; + char space2[14]; + char size[LPROS2_SIZSIZ]; + char space3[4]; + char status[LPROS2_STATSIZ]; + char space4[4]; + char owner[LPROS2_OWNSIZ]; + char terminator; + } os2_lpq_line; + + char parse_line_char[sizeof(os2_lpq_line)]; + os2_lpq_line *parse_line = (os2_lpq_line *)parse_line_char; +#define LPROS2_PRINTING "Printing" +#define LPROS2_WAITING "Queued" +#define LPROS2_PAUSED "Paused" + + memset(parse_line_char, '\0', sizeof(parse_line_char)); + strncpy(parse_line_char, line, sizeof(parse_line_char) -1); + + if (strlen(parse_line_char) != sizeof(parse_line_char) - 1) { + return False; + } + + /* Get the jobid */ + buf->sysjob = atoi(parse_line->jobid); + + /* Get the job name */ + parse_line->space2[0] = '\0'; + trim_char(parse_line->jobname, '\0', ' '); + fstrcpy(buf->fs_file, parse_line->jobname); + + buf->priority = 0; + buf->size = atoi(parse_line->size); + buf->time = time(NULL); + + /* Make sure we have an owner */ + if (!strlen(parse_line->owner)) { + return False; + } + + /* Make sure we have a valid status */ + parse_line->space4[0] = '\0'; + trim_char(parse_line->status, '\0', ' '); + if (!strequal(parse_line->status, LPROS2_PRINTING) && + !strequal(parse_line->status, LPROS2_PAUSED) && + !strequal(parse_line->status, LPROS2_WAITING)) { + return False; + } + + fstrcpy(buf->fs_user, parse_line->owner); + if (strequal(parse_line->status, LPROS2_PRINTING)) { + buf->status = LPQ_PRINTING; + } else if (strequal(parse_line->status, LPROS2_PAUSED)) { + buf->status = LPQ_PAUSED; + } else { + buf->status = LPQ_QUEUED; + } + + return True; +} + +static const char *stat0_strings[] = { "enabled", "online", "idle", "no entries", "free", "ready", NULL }; +static const char *stat1_strings[] = { "offline", "disabled", "down", "off", "waiting", "no daemon", NULL }; +static const char *stat2_strings[] = { "jam", "paper", "error", "responding", "not accepting", "not running", "turned off", NULL }; + +#ifdef DEVELOPER + +/**************************************************************************** +parse a vlp line +****************************************************************************/ + +static bool parse_lpq_vlp(char *line,print_queue_struct *buf,bool first) +{ + int toknum = 0; + char *tok; + TALLOC_CTX *frame = talloc_stackframe(); + const char *cline = line; + + /* First line is printer status */ + + if (!isdigit(line[0])) { + TALLOC_FREE(frame); + return False; + } + + /* Parse a print job entry */ + + while(next_token_talloc(frame, &cline, &tok, NULL)) { + switch (toknum) { + case 0: + buf->sysjob = atoi(tok); + break; + case 1: + buf->size = atoi(tok); + break; + case 2: + buf->status = atoi(tok); + break; + case 3: + buf->time = atoi(tok); + break; + case 4: + fstrcpy(buf->fs_user, tok); + break; + case 5: + fstrcpy(buf->fs_file, tok); + break; + } + toknum++; + } + + TALLOC_FREE(frame); + return True; +} + +#endif /* DEVELOPER */ + +/**************************************************************************** +parse a lpq line. Choose printing style +****************************************************************************/ + +bool parse_lpq_entry(enum printing_types printing_type,char *line, + print_queue_struct *buf, + print_status_struct *status,bool first) +{ + bool ret; + + switch (printing_type) { + case PRINT_SYSV: + ret = parse_lpq_sysv(line,buf,first); + break; + case PRINT_AIX: + ret = parse_lpq_aix(line,buf,first); + break; + case PRINT_HPUX: + ret = parse_lpq_hpux(line,buf,first); + break; + case PRINT_QNX: + ret = parse_lpq_qnx(line,buf,first); + break; + case PRINT_LPRNG: + ret = parse_lpq_lprng(line,buf,first); + break; + case PRINT_PLP: + ret = parse_lpq_plp(line,buf,first); + break; + case PRINT_LPRNT: + ret = parse_lpq_nt(line,buf,first); + break; + case PRINT_LPROS2: + ret = parse_lpq_os2(line,buf,first); + break; +#ifdef DEVELOPER + case PRINT_VLP: + case PRINT_TEST: + ret = parse_lpq_vlp(line,buf,first); + break; +#endif /* DEVELOPER */ + default: + ret = parse_lpq_bsd(line,buf,first); + break; + } + + /* We don't want the newline in the status message. */ + { + char *p = strchr_m(line,'\n'); + if (p) { + *p = 0; + } + } + + /* in the LPRNG case, we skip lines starting by a space.*/ + if (!ret && (printing_type==PRINT_LPRNG) ) { + if (line[0]==' ') { + return ret; + } + } + + if (status && !ret) { + /* a few simple checks to see if the line might be a + printer status line: + handle them so that most severe condition is shown */ + int i; + if (!strlower_m(line)) { + return false; + } + + switch (status->status) { + case LPSTAT_OK: + for (i=0; stat0_strings[i]; i++) { + if (strstr_m(line,stat0_strings[i])) { + fstrcpy(status->message,line); + status->status=LPSTAT_OK; + return ret; + } + } + FALL_THROUGH; + case LPSTAT_STOPPED: + for (i=0; stat1_strings[i]; i++) { + if (strstr_m(line,stat1_strings[i])) { + fstrcpy(status->message,line); + status->status=LPSTAT_STOPPED; + return ret; + } + } + FALL_THROUGH; + case LPSTAT_ERROR: + for (i=0; stat2_strings[i]; i++) { + if (strstr_m(line,stat2_strings[i])) { + fstrcpy(status->message,line); + status->status=LPSTAT_ERROR; + return ret; + } + } + break; + } + } + + return ret; +} + diff --git a/source3/printing/notify.c b/source3/printing/notify.c new file mode 100644 index 0000000..8312b0b --- /dev/null +++ b/source3/printing/notify.c @@ -0,0 +1,693 @@ +/* + Unix SMB/Netbios implementation. + Version 3.0 + printing backend routines + Copyright (C) Tim Potter, 2002 + Copyright (C) Gerald Carter, 2002 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "printing.h" +#include "../librpc/gen_ndr/spoolss.h" +#include "nt_printing.h" +#include "printing/notify.h" +#include "messages.h" +#include "util_tdb.h" +#include "lib/util/string_wrappers.h" + +static TALLOC_CTX *send_ctx; + +static unsigned int num_messages; + +static struct notify_queue { + struct notify_queue *next, *prev; + struct spoolss_notify_msg *msg; + struct timeval tv; + uint8_t *buf; + size_t buflen; +} *notify_queue_head = NULL; + +static struct tevent_timer *notify_event; + +static bool print_notify_pid_list(const char *printername, TALLOC_CTX *mem_ctx, + size_t *p_num_pids, pid_t **pp_pid_list); + +static bool create_send_ctx(void) +{ + if (!send_ctx) + send_ctx = talloc_init("print notify queue"); + + if (!send_ctx) + return False; + + return True; +} + +/**************************************************************************** + Turn a queue name into a snum. +****************************************************************************/ + +int print_queue_snum(const char *qname) +{ + int snum = lp_servicenumber(qname); + if (snum == -1 || !lp_printable(snum)) + return -1; + return snum; +} + +/******************************************************************* + Used to decide if we need a short select timeout. +*******************************************************************/ + +static bool print_notify_messages_pending(void) +{ + return (notify_queue_head != NULL); +} + +/******************************************************************* + Flatten data into a message. +*******************************************************************/ + +static bool flatten_message(struct notify_queue *q) +{ + struct spoolss_notify_msg *msg = q->msg; + uint8_t *buf = NULL; + size_t buflen = 0, len; + +again: + len = 0; + + /* Pack header */ + + len += tdb_pack(buf ? buf + len : NULL, + buf ? buflen - len : 0, "f", msg->printer); + + len += tdb_pack(buf ? buf + len : NULL, + buf ? buflen - len : 0, "ddddddd", + (uint32_t)q->tv.tv_sec, (uint32_t)q->tv.tv_usec, + msg->type, msg->field, msg->id, msg->len, msg->flags); + + /* Pack data */ + + if (msg->len == 0) + len += tdb_pack(buf ? buf + len : NULL, + buf ? buflen - len : 0, "dd", + msg->notify.value[0], msg->notify.value[1]); + else + len += tdb_pack(buf ? buf + len : NULL, + buf ? buflen - len : 0, "B", + msg->len, msg->notify.data); + + if (buflen != len) { + buf = (uint8_t *)TALLOC_REALLOC(send_ctx, buf, len); + if (!buf) + return False; + buflen = len; + goto again; + } + + q->buf = buf; + q->buflen = buflen; + + return True; +} + +/******************************************************************* + Send the batched messages - on a per-printer basis. +*******************************************************************/ + +static void print_notify_send_messages_to_printer(struct messaging_context *msg_ctx, + const char *printer, + unsigned int timeout) +{ + char *buf; + struct notify_queue *pq, *pq_next; + size_t msg_count = 0, offset = 0; + size_t num_pids = 0; + size_t i; + pid_t *pid_list = NULL; + struct timeval end_time = timeval_zero(); + + /* Count the space needed to send the messages. */ + for (pq = notify_queue_head; pq; pq = pq->next) { + if (strequal(printer, pq->msg->printer)) { + if (!flatten_message(pq)) { + DEBUG(0,("print_notify_send_messages: Out of memory\n")); + talloc_free_children(send_ctx); + num_messages = 0; + return; + } + offset += (pq->buflen + 4); + msg_count++; + } + } + offset += 4; /* For count. */ + + buf = (char *)TALLOC(send_ctx, offset); + if (!buf) { + DEBUG(0,("print_notify_send_messages: Out of memory\n")); + talloc_free_children(send_ctx); + num_messages = 0; + return; + } + + offset = 0; + SIVAL(buf,offset,msg_count); + offset += 4; + for (pq = notify_queue_head; pq; pq = pq_next) { + pq_next = pq->next; + + if (strequal(printer, pq->msg->printer)) { + SIVAL(buf,offset,pq->buflen); + offset += 4; + memcpy(buf + offset, pq->buf, pq->buflen); + offset += pq->buflen; + + /* Remove from list. */ + DLIST_REMOVE(notify_queue_head, pq); + } + } + + DEBUG(5, ("print_notify_send_messages_to_printer: sending %lu print notify message%s to printer %s\n", + (unsigned long)msg_count, msg_count != 1 ? "s" : "", printer)); + + /* + * Get the list of PID's to send to. + */ + + if (!print_notify_pid_list(printer, send_ctx, &num_pids, &pid_list)) + return; + + if (timeout != 0) { + end_time = timeval_current_ofs(timeout, 0); + } + + for (i = 0; i < num_pids; i++) { + messaging_send_buf(msg_ctx, + pid_to_procid(pid_list[i]), + MSG_PRINTER_NOTIFY2 | MSG_FLAG_LOWPRIORITY, + (uint8_t *)buf, offset); + + if ((timeout != 0) && timeval_expired(&end_time)) { + break; + } + } +} + +/******************************************************************* + Actually send the batched messages. +*******************************************************************/ + +void print_notify_send_messages(struct messaging_context *msg_ctx, + unsigned int timeout) +{ + if (!print_notify_messages_pending()) + return; + + if (!create_send_ctx()) + return; + + while (print_notify_messages_pending()) + print_notify_send_messages_to_printer( + msg_ctx, notify_queue_head->msg->printer, timeout); + + talloc_free_children(send_ctx); + num_messages = 0; +} + +/******************************************************************* + Event handler to send the messages. +*******************************************************************/ + +static void print_notify_event_send_messages(struct tevent_context *event_ctx, + struct tevent_timer *te, + struct timeval now, + void *private_data) +{ + struct messaging_context *msg_ctx = talloc_get_type_abort( + private_data, struct messaging_context); + /* Remove this timed event handler. */ + TALLOC_FREE(notify_event); + + change_to_root_user(); + print_notify_send_messages(msg_ctx, 0); +} + +/********************************************************************** + deep copy a SPOOLSS_NOTIFY_MSG structure using a TALLOC_CTX + *********************************************************************/ + +static bool copy_notify2_msg( SPOOLSS_NOTIFY_MSG *to, SPOOLSS_NOTIFY_MSG *from ) +{ + + if ( !to || !from ) + return False; + + memcpy( to, from, sizeof(SPOOLSS_NOTIFY_MSG) ); + + if ( from->len ) { + to->notify.data = (char *)talloc_memdup(send_ctx, from->notify.data, from->len ); + if ( !to->notify.data ) { + DEBUG(0,("copy_notify2_msg: talloc_memdup() of size [%d] failed!\n", from->len )); + return False; + } + } + + + return True; +} + +/******************************************************************* + Batch up print notify messages. +*******************************************************************/ + +static void send_spoolss_notify2_msg(struct tevent_context *ev, + struct messaging_context *msg_ctx, + SPOOLSS_NOTIFY_MSG *msg) +{ + struct notify_queue *pnqueue, *tmp_ptr; + + /* + * Ensure we only have one job total_bytes and job total_pages for + * each job. There is no point in sending multiple messages that match + * as they will just cause flickering updates in the client. + */ + + if ((num_messages < 100) && (msg->type == JOB_NOTIFY_TYPE) + && (msg->field == JOB_NOTIFY_FIELD_TOTAL_BYTES + || msg->field == JOB_NOTIFY_FIELD_TOTAL_PAGES )) + { + + for (tmp_ptr = notify_queue_head; tmp_ptr; tmp_ptr = tmp_ptr->next) + { + if (tmp_ptr->msg->type == msg->type && + tmp_ptr->msg->field == msg->field && + tmp_ptr->msg->id == msg->id && + tmp_ptr->msg->flags == msg->flags && + strequal(tmp_ptr->msg->printer, msg->printer)) { + + DEBUG(5,("send_spoolss_notify2_msg: replacing message 0x%02x/0x%02x for " + "printer %s in notify_queue\n", msg->type, msg->field, msg->printer)); + + tmp_ptr->msg = msg; + return; + } + } + } + + /* Store the message on the pending queue. */ + + pnqueue = talloc(send_ctx, struct notify_queue); + if (!pnqueue) { + DEBUG(0,("send_spoolss_notify2_msg: Out of memory.\n")); + return; + } + + /* allocate a new msg structure and copy the fields */ + + if ( !(pnqueue->msg = talloc(send_ctx, SPOOLSS_NOTIFY_MSG)) ) { + DEBUG(0,("send_spoolss_notify2_msg: talloc() of size [%lu] failed!\n", + (unsigned long)sizeof(SPOOLSS_NOTIFY_MSG))); + return; + } + copy_notify2_msg(pnqueue->msg, msg); + GetTimeOfDay(&pnqueue->tv); + pnqueue->buf = NULL; + pnqueue->buflen = 0; + + DEBUG(5, ("send_spoolss_notify2_msg: appending message 0x%02x/0x%02x for printer %s \ +to notify_queue_head\n", msg->type, msg->field, msg->printer)); + + /* + * Note we add to the end of the list to ensure + * the messages are sent in the order they were received. JRA. + */ + + DLIST_ADD_END(notify_queue_head, pnqueue); + num_messages++; + + if ((notify_event == NULL) && (ev != NULL)) { + /* Add an event for 1 second's time to send this queue. */ + notify_event = tevent_add_timer( + ev, NULL, timeval_current_ofs(1,0), + print_notify_event_send_messages, msg_ctx); + } + +} + +static void send_notify_field_values(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t type, + uint32_t field, uint32_t id, uint32_t value1, + uint32_t value2, uint32_t flags) +{ + struct spoolss_notify_msg *msg; + + if (lp_disable_spoolss()) + return; + + if (!create_send_ctx()) + return; + + msg = talloc_zero(send_ctx, struct spoolss_notify_msg); + if (!msg) + return; + + fstrcpy(msg->printer, sharename); + msg->type = type; + msg->field = field; + msg->id = id; + msg->notify.value[0] = value1; + msg->notify.value[1] = value2; + msg->flags = flags; + + send_spoolss_notify2_msg(ev, msg_ctx, msg); +} + +static void send_notify_field_buffer(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t type, + uint32_t field, uint32_t id, uint32_t len, + const char *buffer) +{ + struct spoolss_notify_msg *msg; + + if (lp_disable_spoolss()) + return; + + if (!create_send_ctx()) + return; + + msg = talloc_zero(send_ctx, struct spoolss_notify_msg); + if (!msg) + return; + + fstrcpy(msg->printer, sharename); + msg->type = type; + msg->field = field; + msg->id = id; + msg->len = len; + msg->notify.data = discard_const_p(char, buffer); + + send_spoolss_notify2_msg(ev, msg_ctx, msg); +} + +/* Send a message that the printer status has changed */ + +void notify_printer_status_byname(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t status) +{ + /* Printer status stored in value1 */ + + int snum = print_queue_snum(sharename); + + send_notify_field_values(ev, msg_ctx, sharename, PRINTER_NOTIFY_TYPE, + PRINTER_NOTIFY_FIELD_STATUS, snum, + status, 0, 0); +} + +void notify_printer_status(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, uint32_t status) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + if (sharename) + notify_printer_status_byname(ev, msg_ctx, sharename, status); +} + +void notify_job_status_byname(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + uint32_t status, + uint32_t flags) +{ + /* Job id stored in id field, status in value1 */ + + send_notify_field_values(ev, msg_ctx, + sharename, JOB_NOTIFY_TYPE, + JOB_NOTIFY_FIELD_STATUS, jobid, + status, 0, flags); +} + +void notify_job_status(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, uint32_t status) +{ + notify_job_status_byname(ev, msg_ctx, sharename, jobid, status, 0); +} + +void notify_job_total_bytes(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + uint32_t size) +{ + /* Job id stored in id field, status in value1 */ + + send_notify_field_values(ev, msg_ctx, + sharename, JOB_NOTIFY_TYPE, + JOB_NOTIFY_FIELD_TOTAL_BYTES, jobid, + size, 0, 0); +} + +void notify_job_total_pages(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + uint32_t pages) +{ + /* Job id stored in id field, status in value1 */ + + send_notify_field_values(ev, msg_ctx, + sharename, JOB_NOTIFY_TYPE, + JOB_NOTIFY_FIELD_TOTAL_PAGES, jobid, + pages, 0, 0); +} + +void notify_job_username(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, char *name) +{ + send_notify_field_buffer( + ev, msg_ctx, + sharename, JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_USER_NAME, + jobid, strlen(name) + 1, name); +} + +void notify_job_name(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, char *name) +{ + send_notify_field_buffer( + ev, msg_ctx, + sharename, JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_DOCUMENT, + jobid, strlen(name) + 1, name); +} + +void notify_job_submitted(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + time_t submitted) +{ + send_notify_field_buffer( + ev, msg_ctx, + sharename, JOB_NOTIFY_TYPE, JOB_NOTIFY_FIELD_SUBMITTED, + jobid, sizeof(submitted), (char *)&submitted); +} + +void notify_printer_driver(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *driver_name) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_DRIVER_NAME, + snum, strlen(driver_name) + 1, driver_name); +} + +void notify_printer_comment(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *comment) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_COMMENT, + snum, strlen(comment) + 1, comment); +} + +void notify_printer_sharename(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *share_name) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SHARE_NAME, + snum, strlen(share_name) + 1, share_name); +} + +void notify_printer_printername(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *printername) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PRINTER_NAME, + snum, strlen(printername) + 1, printername); +} + +void notify_printer_port(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *port_name) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_PORT_NAME, + snum, strlen(port_name) + 1, port_name); +} + +void notify_printer_location(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *location) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_LOCATION, + snum, strlen(location) + 1, location); +} + +void notify_printer_sepfile(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *sepfile) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *sharename = lp_servicename(talloc_tos(), lp_sub, snum); + + send_notify_field_buffer( + ev, msg_ctx, + sharename, PRINTER_NOTIFY_TYPE, PRINTER_NOTIFY_FIELD_SEPFILE, + snum, strlen(sepfile) + 1, sepfile); +} + + +void notify_printer_byname(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *printername, uint32_t change, + const char *value) +{ + int snum = print_queue_snum(printername); + int type = PRINTER_NOTIFY_TYPE; + + if ( snum == -1 ) + return; + + send_notify_field_buffer( + ev, msg_ctx, + printername, type, change, snum, strlen(value)+1, value ); +} + + +/**************************************************************************** + Return a malloced list of pid_t's that are interested in getting update + messages on this print queue. Used in printing/notify to send the messages. +****************************************************************************/ + +static bool print_notify_pid_list(const char *printername, TALLOC_CTX *mem_ctx, + size_t *p_num_pids, pid_t **pp_pid_list) +{ + struct tdb_print_db *pdb = NULL; + TDB_CONTEXT *tdb = NULL; + TDB_DATA data; + bool ret = True; + size_t i, num_pids, offset; + pid_t *pid_list; + + *p_num_pids = 0; + *pp_pid_list = NULL; + + pdb = get_print_db_byname(printername); + if (!pdb) + return False; + tdb = pdb->tdb; + + if (tdb_read_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) { + DEBUG(0,("print_notify_pid_list: Failed to lock printer %s database\n", + printername)); + if (pdb) + release_print_db(pdb); + return False; + } + + data = get_printer_notify_pid_list( tdb, printername, True ); + + if (!data.dptr) { + ret = True; + goto done; + } + + num_pids = data.dsize / 8; + + if (num_pids) { + if ((pid_list = talloc_array(mem_ctx, pid_t, num_pids)) == NULL) { + ret = False; + goto done; + } + } else { + pid_list = NULL; + } + + for( i = 0, offset = 0; i < num_pids; offset += 8, i++) + pid_list[i] = (pid_t)IVAL(data.dptr, offset); + + *pp_pid_list = pid_list; + *p_num_pids = num_pids; + + ret = True; + + done: + + tdb_read_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY); + if (pdb) + release_print_db(pdb); + SAFE_FREE(data.dptr); + return ret; +} diff --git a/source3/printing/notify.h b/source3/printing/notify.h new file mode 100644 index 0000000..427bbf0 --- /dev/null +++ b/source3/printing/notify.h @@ -0,0 +1,87 @@ +#ifndef _PRINTING_NOTIFY_H_ +#define _PRINTING_NOTIFY_H_ + +/* + Unix SMB/Netbios implementation. + Version 3.0 + printing backend routines + Copyright (C) Tim Potter, 2002 + Copyright (C) Gerald Carter, 2002 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* The following definitions come from printing/notify.c */ + +int print_queue_snum(const char *qname); +void print_notify_send_messages(struct messaging_context *msg_ctx, + unsigned int timeout); +void notify_printer_status_byname(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t status); +void notify_printer_status(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, uint32_t status); +void notify_job_status_byname(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + uint32_t status, + uint32_t flags); +void notify_job_status(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, uint32_t status); +void notify_job_total_bytes(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + uint32_t size); +void notify_job_total_pages(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + uint32_t pages); +void notify_job_username(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, char *name); +void notify_job_name(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, char *name); +void notify_job_submitted(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, + time_t submitted); +void notify_printer_driver(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *driver_name); +void notify_printer_comment(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *comment); +void notify_printer_sharename(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *share_name); +void notify_printer_printername(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *printername); +void notify_printer_port(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *port_name); +void notify_printer_location(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *location); +void notify_printer_byname(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *printername, uint32_t change, + const char *value); +void notify_printer_sepfile(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, const char *sepfile); +#endif diff --git a/source3/printing/nt_printing.c b/source3/printing/nt_printing.c new file mode 100644 index 0000000..7907fb4 --- /dev/null +++ b/source3/printing/nt_printing.c @@ -0,0 +1,2419 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (C) Andrew Tridgell 1992-2000, + * Copyright (C) Jean François Micouleau 1998-2000. + * Copyright (C) Gerald Carter 2002-2005. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "printing/nt_printing_tdb.h" +#include "printing/queue_process.h" +#include "../librpc/gen_ndr/ndr_spoolss.h" +#include "rpc_server/spoolss/srv_spoolss_util.h" +#include "nt_printing.h" +#include "secrets.h" +#include "../librpc/gen_ndr/netlogon.h" +#include "../libcli/security/security.h" +#include "passdb/machine_sid.h" +#include "smbd/smbd.h" +#include "auth.h" +#include "messages.h" +#include "rpc_server/spoolss/srv_spoolss_nt.h" +#include "rpc_client/cli_winreg_spoolss.h" +#include "lib/util/string_wrappers.h" +#include "lib/global_contexts.h" + +/* Map generic permissions to printer object specific permissions */ + +const struct generic_mapping printer_generic_mapping = { + PRINTER_READ, + PRINTER_WRITE, + PRINTER_EXECUTE, + PRINTER_ALL_ACCESS +}; + +/* Map generic permissions to print server object specific permissions */ + +const struct generic_mapping printserver_generic_mapping = { + SERVER_READ, + SERVER_WRITE, + SERVER_EXECUTE, + SERVER_ALL_ACCESS +}; + +/* Map generic permissions to job object specific permissions */ + +const struct generic_mapping job_generic_mapping = { + JOB_READ, + JOB_WRITE, + JOB_EXECUTE, + JOB_ALL_ACCESS +}; + +static bool print_driver_directories_init(void) +{ + int service; + size_t i; + char *driver_path; + bool ok; + TALLOC_CTX *mem_ctx = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + const char *dir_list[] = { + "W32X86/PCC", + "x64/PCC", + "ARM64", + "color" + }; + + service = lp_servicenumber("print$"); + if (service < 0) { + /* We don't have a print$ share */ + DEBUG(5, ("No print$ share has been configured.\n")); + talloc_free(mem_ctx); + return true; + } + + driver_path = lp_path(mem_ctx, lp_sub, service); + if (driver_path == NULL) { + talloc_free(mem_ctx); + return false; + } + + ok = directory_create_or_exist(driver_path, 0755); + if (!ok) { + DEBUG(1, ("Failed to create printer driver directory %s\n", + driver_path)); + talloc_free(mem_ctx); + return false; + } + + for (i = 0; archi_table[i].long_archi != NULL; i++) { + const char *arch_path; + + arch_path = talloc_asprintf(mem_ctx, + "%s/%s", + driver_path, + archi_table[i].short_archi); + if (arch_path == NULL) { + talloc_free(mem_ctx); + return false; + } + + ok = directory_create_or_exist(arch_path, 0755); + if (!ok) { + DEBUG(1, ("Failed to create printer driver " + "architecture directory %s\n", + arch_path)); + talloc_free(mem_ctx); + return false; + } + } + + for (i = 0; i < ARRAY_SIZE(dir_list); i++) { + const char *path; + + path = talloc_asprintf(mem_ctx, + "%s/%s", + driver_path, + dir_list[i]); + if (path == NULL) { + talloc_free(mem_ctx); + return false; + } + + ok = directory_create_or_exist(path, 0755); + if (!ok) { + DEBUG(1, ("Failed to create printer driver " + "architecture directory %s\n", + path)); + talloc_free(mem_ctx); + return false; + } + } + + driver_path = state_path(talloc_tos(), "DriverStore"); + if (driver_path == NULL) { + talloc_free(mem_ctx); + return false; + } + + ok = directory_create_or_exist(driver_path, 0755); + if (!ok) { + DEBUG(1,("failed to create path %s\n", driver_path)); + talloc_free(mem_ctx); + return false; + } + + driver_path = state_path(talloc_tos(), "DriverStore/FileRepository"); + if (driver_path == NULL) { + talloc_free(mem_ctx); + return false; + } + + ok = directory_create_or_exist(driver_path, 0755); + if (!ok) { + DEBUG(1,("failed to create path %s\n", driver_path)); + talloc_free(mem_ctx); + return false; + } + + driver_path = state_path(talloc_tos(), "DriverStore/Temp"); + if (driver_path == NULL) { + talloc_free(mem_ctx); + return false; + } + + ok = directory_create_or_exist(driver_path, 0755); + if (!ok) { + DEBUG(1,("failed to create path %s\n", driver_path)); + talloc_free(mem_ctx); + return false; + } + + talloc_free(mem_ctx); + return true; +} + +/**************************************************************************** + Forward a MSG_PRINTER_DRVUPGRADE message from another smbd to the + background lpq updater. +****************************************************************************/ + +static void forward_drv_upgrade_printer_msg(struct messaging_context *msg, + void *private_data, + uint32_t msg_type, + struct server_id server_id, + DATA_BLOB *data) +{ + send_to_bgqd(msg, msg_type, data->data, data->length); +} + +/**************************************************************************** + Open the NT printing tdbs. Done once before fork(). +****************************************************************************/ + +bool nt_printing_init(struct messaging_context *msg_ctx) +{ + WERROR win_rc; + + if (!print_driver_directories_init()) { + return false; + } + + if (!nt_printing_tdb_upgrade()) { + return false; + } + + /* + * register callback to handle updating printers as new + * drivers are installed. Forwards to background lpq updater. + */ + messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE, + forward_drv_upgrade_printer_msg); + + if ( lp_security() == SEC_ADS ) { + win_rc = check_published_printers(msg_ctx); + if (!W_ERROR_IS_OK(win_rc)) + DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", win_errstr(win_rc))); + } + + return true; +} + +/******************************************************************* + Function to allow filename parsing "the old way". +********************************************************************/ + +static NTSTATUS driver_unix_convert(connection_struct *conn, + const char *old_name, + struct files_struct **pdirfsp, + struct smb_filename **psmb_fname) +{ + NTSTATUS status; + TALLOC_CTX *ctx = talloc_tos(); + char *name = talloc_strdup(ctx, old_name); + + if (!name) { + return NT_STATUS_NO_MEMORY; + } + unix_format(name); + name = unix_clean_name(ctx, name); + if (!name) { + return NT_STATUS_NO_MEMORY; + } + trim_string(name,"/","/"); + + status = filename_convert_dirfsp(ctx, + conn, + name, + 0, /* ucf_flags */ + 0, /* twrp */ + pdirfsp, + psmb_fname); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + return NT_STATUS_OK; +} + +/**************************************************************************** + Function to do the mapping between the long architecture name and + the short one. +****************************************************************************/ + +const char *get_short_archi(const char *long_archi) +{ + int i=-1; + + DEBUG(107,("Getting architecture dependent directory\n")); + do { + i++; + } while ( (archi_table[i].long_archi!=NULL ) && + strcasecmp_m(long_archi, archi_table[i].long_archi) ); + + if (archi_table[i].long_archi==NULL) { + DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi)); + return NULL; + } + + /* this might be client code - but shouldn't this be an fstrcpy etc? */ + + DEBUGADD(108,("index: [%d]\n", i)); + DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi)); + DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi)); + + return archi_table[i].short_archi; +} + +/**************************************************************************** + Read data from fsp on the vfs. +****************************************************************************/ + +static ssize_t printing_pread_data(files_struct *fsp, + char *buf, + off_t *poff, + size_t byte_count) +{ + size_t total=0; + off_t in_pos = *poff; + + /* Don't allow integer wrap on read. */ + if (in_pos + byte_count < in_pos) { + return -1; + } + + while (total < byte_count) { + ssize_t ret = read_file(fsp, + buf + total, + in_pos, + byte_count - total); + + if (ret == 0) { + *poff = in_pos; + return total; + } + if (ret == -1) { + if (errno == EINTR) { + continue; + } else { + return -1; + } + } + in_pos += ret; + total += ret; + } + *poff = in_pos; + return (ssize_t)total; +} + +/**************************************************************************** + Detect the major and minor version of a PE file. + Returns: + + 1 if file is a PE file and we got version numbers, + 0 if this file is a PE file and we couldn't get the version numbers, + -1 on error. + + NB. buf is passed into and freed inside this function. This is a + bad API design, but fixing this is a task for another day. +****************************************************************************/ + +static int handle_pe_file(files_struct *fsp, + off_t in_pos, + char *fname, + char *buf, + uint32_t *major, + uint32_t *minor) +{ + unsigned int i; + unsigned int num_sections; + unsigned int section_table_bytes; + ssize_t byte_count; + off_t rel_pos; + int ret = -1; + + /* Just skip over optional header to get to section table */ + rel_pos = SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)- + (NE_HEADER_SIZE-PE_HEADER_SIZE); + + if (in_pos + rel_pos < in_pos) { + /* Integer wrap. */ + goto out; + } + in_pos = rel_pos + in_pos; + + /* get the section table */ + num_sections = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS); + + if (num_sections >= (UINT_MAX / PE_HEADER_SECT_HEADER_SIZE)) { + /* Integer wrap. */ + goto out; + } + + section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE; + if (section_table_bytes == 0) { + goto out; + } + + SAFE_FREE(buf); + buf = (char *)SMB_MALLOC(section_table_bytes); + if (buf == NULL) { + DBG_ERR("PE file [%s] section table malloc " + "failed bytes = %d\n", + fname, + section_table_bytes); + goto out; + } + + byte_count = printing_pread_data(fsp, buf, &in_pos, section_table_bytes); + if (byte_count < section_table_bytes) { + DBG_NOTICE("PE file [%s] Section header too short, " + "bytes read = %lu\n", + fname, + (unsigned long)byte_count); + goto out; + } + + /* + * Iterate the section table looking for + * the resource section ".rsrc" + */ + for (i = 0; i < num_sections; i++) { + int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE; + + if (strcmp(".rsrc", + &buf[sec_offset+ PE_HEADER_SECT_NAME_OFFSET]) == 0) { + unsigned int section_pos = IVAL(buf, + sec_offset+ + PE_HEADER_SECT_PTR_DATA_OFFSET); + unsigned int section_bytes = IVAL(buf, + sec_offset+ + PE_HEADER_SECT_SIZE_DATA_OFFSET); + + if (section_bytes == 0) { + goto out; + } + + SAFE_FREE(buf); + buf=(char *)SMB_MALLOC(section_bytes); + if (buf == NULL) { + DBG_ERR("PE file [%s] version malloc " + "failed bytes = %d\n", + fname, + section_bytes); + goto out; + } + + /* + * Read from the start of the .rsrc + * section info + */ + in_pos = section_pos; + + byte_count = printing_pread_data(fsp, + buf, + &in_pos, + section_bytes); + if (byte_count < section_bytes) { + DBG_NOTICE("PE file " + "[%s] .rsrc section too short, " + "bytes read = %lu\n", + fname, + (unsigned long)byte_count); + goto out; + } + + if (section_bytes < VS_VERSION_INFO_UNICODE_SIZE) { + goto out; + } + + for (i=0; + i< section_bytes - VS_VERSION_INFO_UNICODE_SIZE; + i++) { + /* + * Scan for 1st 3 unicoded bytes + * followed by word aligned magic + * value. + */ + int mpos; + bool magic_match = false; + + if (buf[i] == 'V' && + buf[i+1] == '\0' && + buf[i+2] == 'S') { + magic_match = true; + } + + if (magic_match == false) { + continue; + } + + /* Align to next long address */ + mpos = (i + sizeof(VS_SIGNATURE)*2 + + 3) & 0xfffffffc; + + if (IVAL(buf,mpos) == VS_MAGIC_VALUE) { + *major = IVAL(buf, + mpos+ VS_MAJOR_OFFSET); + *minor = IVAL(buf, + mpos+ VS_MINOR_OFFSET); + + DBG_INFO("PE file [%s] Version = " + "%08x:%08x (%d.%d.%d.%d)\n", + fname, + *major, + *minor, + (*major>>16)&0xffff, + *major&0xffff, + (*minor>>16)&0xffff, + *minor&0xffff); + ret = 1; + goto out; + } + } + } + } + + /* Version info not found, fall back to origin date/time */ + DBG_DEBUG("PE file [%s] has no version info\n", fname); + ret = 0; + + out: + + SAFE_FREE(buf); + return ret; +} + +/**************************************************************************** + Detect the major and minor version of an NE file. + Returns: + + 1 if file is an NE file and we got version numbers, + 0 if this file is an NE file and we couldn't get the version numbers, + -1 on error. + + NB. buf is passed into and freed inside this function. This is a + bad API design, but fixing this is a task for another day. +****************************************************************************/ + +static int handle_ne_file(files_struct *fsp, + off_t in_pos, + char *fname, + char *buf, + uint32_t *major, + uint32_t *minor) +{ + unsigned int i; + ssize_t byte_count; + int ret = -1; + + if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) { + DBG_NOTICE("NE file [%s] wrong target OS = 0x%x\n", + fname, + CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)); + /* + * At this point, we assume the file is in error. + * It still could be something else besides a NE file, + * but it unlikely at this point. + */ + goto out; + } + + /* Allocate a bit more space to speed up things */ + SAFE_FREE(buf); + buf=(char *)SMB_MALLOC(VS_NE_BUF_SIZE); + if (buf == NULL) { + DBG_ERR("NE file [%s] malloc failed bytes = %d\n", + fname, + PE_HEADER_SIZE); + goto out; + } + + /* + * This is a HACK! I got tired of trying to sort through the + * messy 'NE' file format. If anyone wants to clean this up + * please have at it, but this works. 'NE' files will + * eventually fade away. JRR + */ + byte_count = printing_pread_data(fsp, buf, &in_pos, VS_NE_BUF_SIZE); + while (byte_count > 0) { + /* + * Cover case that should not occur in a well + * formed 'NE' .dll file + */ + if (byte_count-VS_VERSION_INFO_SIZE <= 0) { + break; + } + + for(i=0; ibyte_count-VS_VERSION_INFO_SIZE) { + ssize_t amount_read; + ssize_t amount_unused = byte_count-i; + + memmove(buf, &buf[i], amount_unused); + amount_read = printing_pread_data(fsp, + &buf[amount_unused], + &in_pos, + VS_NE_BUF_SIZE- amount_unused); + if (amount_read < 0) { + DBG_ERR("NE file [%s] Read " + "error, errno=%d\n", + fname, + errno); + goto out; + } + + if (amount_read + amount_unused < + amount_read) { + /* Check for integer wrap. */ + break; + } + + byte_count = amount_read + + amount_unused; + if (byte_count < VS_VERSION_INFO_SIZE) { + break; + } + + i = 0; + } + + /* + * Check that the full signature string and + * the magic number that follows exist (not + * a perfect solution, but the chances that this + * occurs in code is, well, remote. Yes I know + * I'm comparing the 'V' twice, as it is + * simpler to read the code. + */ + if (strcmp(&buf[i], VS_SIGNATURE) == 0) { + /* + * Compute skip alignment to next + * long address. + */ + off_t cpos = in_pos; + int skip = -(cpos - (byte_count - i) + + sizeof(VS_SIGNATURE)) & 3; + if (IVAL(buf, + i+sizeof(VS_SIGNATURE)+skip) + != 0xfeef04bd) { + byte_count = printing_pread_data(fsp, + buf, + &in_pos, + VS_NE_BUF_SIZE); + continue; + } + + *major = IVAL(buf, + i+sizeof(VS_SIGNATURE)+ + skip+VS_MAJOR_OFFSET); + *minor = IVAL(buf, + i+sizeof(VS_SIGNATURE)+ + skip+VS_MINOR_OFFSET); + DBG_INFO("NE file [%s] Version " + "= %08x:%08x (%d.%d.%d.%d)\n", + fname, + *major, + *minor, + (*major>>16)&0xffff, + *major&0xffff, + (*minor>>16)&0xffff, + *minor&0xffff); + ret = 1; + goto out; + } + } + } + + /* Version info not found, fall back to origin date/time */ + DBG_ERR("NE file [%s] Version info not found\n", fname); + ret = 0; + + out: + + SAFE_FREE(buf); + return ret; +} + +/**************************************************************************** + Version information in Microsoft files is held in a VS_VERSION_INFO structure. + There are two case to be covered here: PE (Portable Executable) and NE (New + Executable) files. Both files support the same INFO structure, but PE files + store the signature in unicode, and NE files store it as !unicode. + returns -1 on error, 1 on version info found, and 0 on no version info found. +****************************************************************************/ + +static int get_file_version(files_struct *fsp, + char *fname, + uint32_t *major, + uint32_t *minor) +{ + char *buf = NULL; + ssize_t byte_count; + off_t in_pos = fh_get_pos(fsp->fh); + + buf=(char *)SMB_MALLOC(DOS_HEADER_SIZE); + if (buf == NULL) { + DBG_ERR("PE file [%s] DOS Header malloc failed bytes = %d\n", + fname, + DOS_HEADER_SIZE); + goto error_exit; + } + + byte_count = printing_pread_data(fsp, buf, &in_pos, DOS_HEADER_SIZE); + if (byte_count < DOS_HEADER_SIZE) { + DBG_NOTICE("File [%s] DOS header too short, bytes read = %lu\n", + fname, + (unsigned long)byte_count); + goto no_version_info; + } + + /* Is this really a DOS header? */ + if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) { + DBG_INFO("File [%s] bad DOS magic = 0x%x\n", + fname, + SVAL(buf,DOS_HEADER_MAGIC_OFFSET)); + goto no_version_info; + } + + /* + * Skip OEM header (if any) and the + * DOS stub to start of Windows header. + */ + in_pos = SVAL(buf,DOS_HEADER_LFANEW_OFFSET); + + /* Note: DOS_HEADER_SIZE and NE_HEADER_SIZE are incidentally same */ + byte_count = printing_pread_data(fsp, buf, &in_pos, NE_HEADER_SIZE); + if (byte_count < NE_HEADER_SIZE) { + DBG_NOTICE("File [%s] Windows header too short, " + "bytes read = %lu\n", + fname, + (unsigned long)byte_count); + /* + * Assume this isn't an error... + * the file just looks sort of like a PE/NE file + */ + goto no_version_info; + } + + /* + * The header may be a PE (Portable Executable) + * or an NE (New Executable). + */ + if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) { + return handle_pe_file(fsp, + in_pos, + fname, + buf, + major, + minor); + } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == + NE_HEADER_SIGNATURE) { + return handle_ne_file(fsp, + in_pos, + fname, + buf, + major, + minor); + } else { + /* + * Assume this isn't an error... the file just + * looks sort of like a PE/NE file. + */ + DBG_NOTICE("File [%s] unknown file format, signature = 0x%x\n", + fname, + IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)); + /* Fallthrough into no_version_info: */ + } + + no_version_info: + SAFE_FREE(buf); + return 0; + + error_exit: + SAFE_FREE(buf); + return -1; +} + +/**************************************************************************** +Drivers for Microsoft systems contain multiple files. Often, multiple drivers +share one or more files. During the MS installation process files are checked +to insure that only a newer version of a shared file is installed over an +older version. There are several possibilities for this comparison. If there +is no previous version, the new one is newer (obviously). If either file is +missing the version info structure, compare the creation date (on Unix use +the modification date). Otherwise chose the numerically larger version number. +****************************************************************************/ + +static int file_version_is_newer(connection_struct *conn, fstring new_file, fstring old_file) +{ + bool use_version = true; + + uint32_t new_major; + uint32_t new_minor; + time_t new_create_time; + + uint32_t old_major; + uint32_t old_minor; + time_t old_create_time; + + struct smb_filename *smb_fname = NULL; + files_struct *fsp = NULL; + struct files_struct *dirfsp = NULL; + SMB_STRUCT_STAT st; + + NTSTATUS status; + int ret; + + SET_STAT_INVALID(st); + new_create_time = (time_t)0; + old_create_time = (time_t)0; + + /* Get file version info (if available) for previous file (if it exists) */ + status = driver_unix_convert(conn, old_file, &dirfsp, &smb_fname); + if (!NT_STATUS_IS_OK(status)) { + goto error_exit; + } + + status = openat_pathref_fsp(conn->cwd_fsp, smb_fname); + if (!NT_STATUS_IS_OK(status)) { + ret = 1; + goto done; + } + + status = SMB_VFS_CREATE_FILE( + conn, /* conn */ + NULL, /* req */ + dirfsp, /* dirfsp */ + smb_fname, /* fname */ + FILE_GENERIC_READ, /* access_mask */ + FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */ + FILE_OPEN, /* create_disposition*/ + 0, /* create_options */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes */ + INTERNAL_OPEN_ONLY, /* oplock_request */ + NULL, /* lease */ + 0, /* allocation_size */ + 0, /* private_flags */ + NULL, /* sd */ + NULL, /* ea_list */ + &fsp, /* result */ + NULL, /* pinfo */ + NULL, NULL); /* create context */ + + if (!NT_STATUS_IS_OK(status)) { + /* Old file not found, so by definition new file is in fact newer */ + DEBUG(10,("file_version_is_newer: Can't open old file [%s], " + "errno = %d\n", smb_fname_str_dbg(smb_fname), + errno)); + ret = 1; + goto done; + + } + + ret = get_file_version(fsp, old_file, &old_major, &old_minor); + if (ret == -1) { + goto error_exit; + } + + if (!ret) { + DEBUG(6,("file_version_is_newer: Version info not found [%s], " + "use mod time\n", + old_file)); + use_version = false; + if (SMB_VFS_FSTAT(fsp, &st) == -1) { + goto error_exit; + } + old_create_time = convert_timespec_to_time_t(st.st_ex_mtime); + DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", + (long)old_create_time)); + } + + close_file_free(NULL, &fsp, NORMAL_CLOSE); + + /* Get file version info (if available) for new file */ + status = driver_unix_convert(conn, new_file, &dirfsp, &smb_fname); + if (!NT_STATUS_IS_OK(status)) { + goto error_exit; + } + + status = openat_pathref_fsp(conn->cwd_fsp, smb_fname); + if (!NT_STATUS_IS_OK(status)) { + DBG_NOTICE("Can't open new file [%s], errno = %d\n", + smb_fname_str_dbg(smb_fname), errno); + goto error_exit; + } + + status = SMB_VFS_CREATE_FILE( + conn, /* conn */ + NULL, /* req */ + dirfsp, /* dirfsp */ + smb_fname, /* fname */ + FILE_GENERIC_READ, /* access_mask */ + FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */ + FILE_OPEN, /* create_disposition*/ + 0, /* create_options */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes */ + INTERNAL_OPEN_ONLY, /* oplock_request */ + NULL, /* lease */ + 0, /* allocation_size */ + 0, /* private_flags */ + NULL, /* sd */ + NULL, /* ea_list */ + &fsp, /* result */ + NULL, /* pinfo */ + NULL, NULL); /* create context */ + + if (!NT_STATUS_IS_OK(status)) { + /* New file not found, this shouldn't occur if the caller did its job */ + DEBUG(3,("file_version_is_newer: Can't open new file [%s], " + "errno = %d\n", smb_fname_str_dbg(smb_fname), errno)); + goto error_exit; + + } + + ret = get_file_version(fsp, new_file, &new_major, &new_minor); + if (ret == -1) { + goto error_exit; + } + + if (!ret) { + DEBUG(6,("file_version_is_newer: Version info not found [%s], " + "use mod time\n", + new_file)); + use_version = false; + if (SMB_VFS_FSTAT(fsp, &st) == -1) { + goto error_exit; + } + new_create_time = convert_timespec_to_time_t(st.st_ex_mtime); + DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", + (long)new_create_time)); + } + + close_file_free(NULL, &fsp, NORMAL_CLOSE); + + if (use_version && (new_major != old_major || new_minor != old_minor)) { + /* Compare versions and choose the larger version number */ + if (new_major > old_major || + (new_major == old_major && new_minor > old_minor)) { + + DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file)); + ret = 1; + goto done; + } + else { + DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file)); + ret = 0; + goto done; + } + + } else { + /* Compare modification time/dates and choose the newest time/date */ + if (new_create_time > old_create_time) { + DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file)); + ret = 1; + goto done; + } + else { + DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file)); + ret = 0; + goto done; + } + } + + error_exit: + if(fsp) + close_file_free(NULL, &fsp, NORMAL_CLOSE); + ret = -1; + done: + TALLOC_FREE(smb_fname); + return ret; +} + +/**************************************************************************** +Determine the correct cVersion associated with an architecture and driver +****************************************************************************/ +static uint32_t get_correct_cversion(const struct auth_session_info *session_info, + const char *architecture, + const char *driverpath_in, + const char *driver_directory, + WERROR *perr) +{ + TALLOC_CTX *frame = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int cversion = -1; + NTSTATUS nt_status; + struct smb_filename *smb_fname = NULL; + files_struct *fsp = NULL; + struct files_struct *dirfsp = NULL; + struct conn_struct_tos *c = NULL; + connection_struct *conn = NULL; + char *printdollar = NULL; + char *printdollar_path = NULL; + char *working_dir = NULL; + int printdollar_snum; + uint32_t major, minor; + int ret; + + *perr = WERR_INVALID_PARAMETER; + + /* If architecture is Windows 95/98/ME, the version is always 0. */ + if (strcmp(architecture, SPL_ARCH_WIN40) == 0) { + DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n")); + *perr = WERR_OK; + TALLOC_FREE(frame); + return 0; + } + + /* If architecture is Windows x64, the version is always 3. */ + if (strcmp(architecture, SPL_ARCH_X64) == 0 || + strcmp(architecture, SPL_ARCH_ARM64) == 0) { + DBG_DEBUG("get_correct_cversion: this architecture must be, cversion = 3\n"); + *perr = WERR_OK; + TALLOC_FREE(frame); + return 3; + } + + printdollar_snum = find_service(frame, "print$", &printdollar); + if (!printdollar) { + *perr = WERR_NOT_ENOUGH_MEMORY; + TALLOC_FREE(frame); + return -1; + } + if (printdollar_snum == -1) { + *perr = WERR_BAD_NET_NAME; + TALLOC_FREE(frame); + return -1; + } + + printdollar_path = lp_path(frame, lp_sub, printdollar_snum); + if (printdollar_path == NULL) { + *perr = WERR_NOT_ENOUGH_MEMORY; + TALLOC_FREE(frame); + return -1; + } + + working_dir = talloc_asprintf(frame, + "%s/%s", + printdollar_path, + architecture); + /* + * If the driver has been uploaded into a temorpary driver + * directory, switch to the driver directory. + */ + if (driver_directory != NULL) { + working_dir = talloc_asprintf(frame, "%s/%s/%s", + printdollar_path, + architecture, + driver_directory); + } + + nt_status = create_conn_struct_tos_cwd(global_messaging_context(), + printdollar_snum, + working_dir, + session_info, + &c); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0,("get_correct_cversion: create_conn_struct " + "returned %s\n", nt_errstr(nt_status))); + *perr = ntstatus_to_werror(nt_status); + TALLOC_FREE(frame); + return -1; + } + conn = c->conn; + + nt_status = set_conn_force_user_group(conn, printdollar_snum); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0, ("failed set force user / group\n")); + *perr = ntstatus_to_werror(nt_status); + goto error_free_conn; + } + + if (!become_user_without_service_by_session(conn, session_info)) { + DEBUG(0, ("failed to become user\n")); + *perr = WERR_ACCESS_DENIED; + goto error_free_conn; + } + + /* + * We switch to the directory where the driver files are located, + * so only work on the file names + */ + nt_status = driver_unix_convert(conn, + driverpath_in, + &dirfsp, + &smb_fname); + if (!NT_STATUS_IS_OK(nt_status)) { + *perr = ntstatus_to_werror(nt_status); + goto error_exit; + } + + nt_status = vfs_file_exist(conn, smb_fname); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(3,("get_correct_cversion: vfs_file_exist failed\n")); + *perr = WERR_FILE_NOT_FOUND; + goto error_exit; + } + + nt_status = openat_pathref_fsp(conn->cwd_fsp, smb_fname); + if (!NT_STATUS_IS_OK(nt_status)) { + DBG_NOTICE("Can't open file [%s]: %s\n", + smb_fname_str_dbg(smb_fname), + nt_errstr(nt_status)); + *perr = WERR_ACCESS_DENIED; + goto error_exit; + } + + nt_status = SMB_VFS_CREATE_FILE( + conn, /* conn */ + NULL, /* req */ + dirfsp, /* dirfsp */ + smb_fname, /* fname */ + FILE_GENERIC_READ, /* access_mask */ + FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */ + FILE_OPEN, /* create_disposition*/ + 0, /* create_options */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes */ + INTERNAL_OPEN_ONLY, /* oplock_request */ + NULL, /* lease */ + 0, /* private_flags */ + 0, /* allocation_size */ + NULL, /* sd */ + NULL, /* ea_list */ + &fsp, /* result */ + NULL, /* pinfo */ + NULL, NULL); /* create context */ + + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = " + "%d\n", smb_fname_str_dbg(smb_fname), errno)); + *perr = WERR_ACCESS_DENIED; + goto error_exit; + } + + ret = get_file_version(fsp, smb_fname->base_name, &major, &minor); + if (ret == -1) { + *perr = WERR_INVALID_PARAMETER; + goto error_exit; + } else if (!ret) { + DEBUG(6,("get_correct_cversion: Version info not " + "found [%s]\n", + smb_fname_str_dbg(smb_fname))); + *perr = WERR_INVALID_PARAMETER; + goto error_exit; + } + + /* + * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION + * for more details. Version in this case is not just the version of the + * file, but the version in the sense of kernel mode (2) vs. user mode + * (3) drivers. Other bits of the version fields are the version info. + * JRR 010716 + */ + cversion = major & 0x0000ffff; + switch (cversion) { + case 2: /* WinNT drivers */ + case 3: /* Win2K drivers */ + break; + + default: + DEBUG(6,("get_correct_cversion: cversion " + "invalid [%s] cversion = %d\n", + smb_fname_str_dbg(smb_fname), + cversion)); + goto error_exit; + } + + DEBUG(10,("get_correct_cversion: Version info found [%s] major" + " = 0x%x minor = 0x%x\n", + smb_fname_str_dbg(smb_fname), major, minor)); + + DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n", + smb_fname_str_dbg(smb_fname), cversion)); + *perr = WERR_OK; + + error_exit: + unbecome_user_without_service(); + error_free_conn: + if (fsp != NULL) { + close_file_free(NULL, &fsp, NORMAL_CLOSE); + } + if (!W_ERROR_IS_OK(*perr)) { + cversion = -1; + } + + TALLOC_FREE(frame); + return cversion; +} + +/**************************************************************************** +****************************************************************************/ + +#define strip_driver_path(_mem_ctx, _element) do { \ + if (_element && ((_p = strrchr((_element), '\\')) != NULL)) { \ + (_element) = talloc_asprintf((_mem_ctx), "%s", _p+1); \ + W_ERROR_HAVE_NO_MEMORY((_element)); \ + } \ +} while (0); + +static WERROR clean_up_driver_struct_level(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + const char *architecture, + const char **driver_path, + const char **data_file, + const char **config_file, + const char **help_file, + struct spoolss_StringArray *dependent_files, + enum spoolss_DriverOSVersion *version, + uint32_t flags, + const char **driver_directory) +{ + const char *short_architecture; + int i; + WERROR err; + char *_p; + + if (!*driver_path || !*data_file) { + return WERR_INVALID_PARAMETER; + } + + if (!strequal(architecture, SPOOLSS_ARCHITECTURE_4_0) && !*config_file) { + return WERR_INVALID_PARAMETER; + } + + if (flags & APD_COPY_FROM_DIRECTORY) { + char *path; + char *q; + + /* + * driver_path is set to: + * + * \\PRINTSRV\print$\x64\{279245b0-a8bd-4431-bf6f-baee92ac15c0}\pscript5.dll + */ + path = talloc_strdup(mem_ctx, *driver_path); + if (path == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + + /* Remove pscript5.dll */ + q = strrchr_m(path, '\\'); + if (q == NULL) { + return WERR_INVALID_PARAMETER; + } + *q = '\0'; + + /* Get \{279245b0-a8bd-4431-bf6f-baee92ac15c0} */ + q = strrchr_m(path, '\\'); + if (q == NULL) { + return WERR_INVALID_PARAMETER; + } + + /* + * Set driver_directory to: + * + * {279245b0-a8bd-4431-bf6f-baee92ac15c0} + * + * This is the directory where all the files have been uploaded + */ + *driver_directory = q + 1; + } + + /* clean up the driver name. + * we can get .\driver.dll + * or worse c:\windows\system\driver.dll ! + */ + /* using an intermediate string to not have overlapping memcpy()'s */ + + strip_driver_path(mem_ctx, *driver_path); + strip_driver_path(mem_ctx, *data_file); + if (*config_file) { + strip_driver_path(mem_ctx, *config_file); + } + if (help_file) { + strip_driver_path(mem_ctx, *help_file); + } + + if (dependent_files && dependent_files->string) { + for (i=0; dependent_files->string[i]; i++) { + strip_driver_path(mem_ctx, dependent_files->string[i]); + } + } + + short_architecture = get_short_archi(architecture); + if (!short_architecture) { + return WERR_UNKNOWN_PRINTER_DRIVER; + } + + /* jfm:7/16/2000 the client always sends the cversion=0. + * The server should check which version the driver is by reading + * the PE header of driver->driverpath. + * + * For Windows 95/98 the version is 0 (so the value sent is correct) + * For Windows NT (the architecture doesn't matter) + * NT 3.1: cversion=0 + * NT 3.5/3.51: cversion=1 + * NT 4: cversion=2 + * NT2K: cversion=3 + */ + + *version = get_correct_cversion(session_info, + short_architecture, + *driver_path, + *driver_directory, + &err); + if (*version == -1) { + return err; + } + + return WERR_OK; +} + +/**************************************************************************** +****************************************************************************/ + +WERROR clean_up_driver_struct(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + const struct spoolss_AddDriverInfoCtr *r, + uint32_t flags, + const char **driver_directory) +{ + switch (r->level) { + case 3: + return clean_up_driver_struct_level(mem_ctx, session_info, + r->info.info3->architecture, + &r->info.info3->driver_path, + &r->info.info3->data_file, + &r->info.info3->config_file, + &r->info.info3->help_file, + r->info.info3->dependent_files, + &r->info.info3->version, + flags, + driver_directory); + case 6: + return clean_up_driver_struct_level(mem_ctx, session_info, + r->info.info6->architecture, + &r->info.info6->driver_path, + &r->info.info6->data_file, + &r->info.info6->config_file, + &r->info.info6->help_file, + r->info.info6->dependent_files, + &r->info.info6->version, + flags, + driver_directory); + case 8: + return clean_up_driver_struct_level(mem_ctx, session_info, + r->info.info8->architecture, + &r->info.info8->driver_path, + &r->info.info8->data_file, + &r->info.info8->config_file, + &r->info.info8->help_file, + r->info.info8->dependent_files, + &r->info.info8->version, + flags, + driver_directory); + default: + return WERR_NOT_SUPPORTED; + } +} + +/**************************************************************************** + This function sucks and should be replaced. JRA. +****************************************************************************/ + +static void convert_level_6_to_level3(struct spoolss_AddDriverInfo3 *dst, + const struct spoolss_AddDriverInfo6 *src) +{ + dst->version = src->version; + + dst->driver_name = src->driver_name; + dst->architecture = src->architecture; + dst->driver_path = src->driver_path; + dst->data_file = src->data_file; + dst->config_file = src->config_file; + dst->help_file = src->help_file; + dst->monitor_name = src->monitor_name; + dst->default_datatype = src->default_datatype; + dst->_ndr_size_dependent_files = src->_ndr_size_dependent_files; + dst->dependent_files = src->dependent_files; +} + +static void convert_level_8_to_level3(struct spoolss_AddDriverInfo3 *dst, + const struct spoolss_AddDriverInfo8 *src) +{ + dst->version = src->version; + + dst->driver_name = src->driver_name; + dst->architecture = src->architecture; + dst->driver_path = src->driver_path; + dst->data_file = src->data_file; + dst->config_file = src->config_file; + dst->help_file = src->help_file; + dst->monitor_name = src->monitor_name; + dst->default_datatype = src->default_datatype; + dst->_ndr_size_dependent_files = src->_ndr_size_dependent_files; + dst->dependent_files = src->dependent_files; +} + +/**************************************************************************** +****************************************************************************/ + +static WERROR move_driver_file_to_download_area(TALLOC_CTX *mem_ctx, + connection_struct *conn, + const char *driver_file, + const char *short_architecture, + uint32_t driver_version, + uint32_t version, + const char *driver_directory) +{ + struct smb_filename *smb_fname_old = NULL; + struct smb_filename *smb_fname_new = NULL; + char *old_name = NULL; + char *new_name = NULL; + NTSTATUS status; + WERROR ret; + + if (driver_directory != NULL) { + old_name = talloc_asprintf(mem_ctx, + "%s/%s/%s", + short_architecture, + driver_directory, + driver_file); + } else { + old_name = talloc_asprintf(mem_ctx, + "%s/%s", + short_architecture, + driver_file); + } + if (old_name == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + + new_name = talloc_asprintf(mem_ctx, "%s/%d/%s", + short_architecture, driver_version, driver_file); + if (new_name == NULL) { + TALLOC_FREE(old_name); + return WERR_NOT_ENOUGH_MEMORY; + } + + if (version != -1 && (version = file_version_is_newer(conn, old_name, new_name)) > 0) { + struct files_struct *dirfsp = NULL; + + status = driver_unix_convert(conn, + old_name, + &dirfsp, + &smb_fname_old); + if (!NT_STATUS_IS_OK(status)) { + ret = WERR_NOT_ENOUGH_MEMORY; + goto out; + } + + /* Setup a synthetic smb_filename struct */ + smb_fname_new = talloc_zero(mem_ctx, struct smb_filename); + if (!smb_fname_new) { + ret = WERR_NOT_ENOUGH_MEMORY; + goto out; + } + + smb_fname_new->base_name = new_name; + + DEBUG(10,("move_driver_file_to_download_area: copying '%s' to " + "'%s'\n", smb_fname_old->base_name, + smb_fname_new->base_name)); + + status = copy_file(mem_ctx, conn, smb_fname_old, smb_fname_new, + FILE_OVERWRITE_IF); + + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0,("move_driver_file_to_download_area: Unable " + "to rename [%s] to [%s]: %s\n", + smb_fname_old->base_name, new_name, + nt_errstr(status))); + ret = WERR_APP_INIT_FAILURE; + goto out; + } + } + + ret = WERR_OK; + out: + TALLOC_FREE(smb_fname_old); + TALLOC_FREE(smb_fname_new); + return ret; +} + +WERROR move_driver_to_download_area(const struct auth_session_info *session_info, + const struct spoolss_AddDriverInfoCtr *r, + const char *driver_directory) +{ + TALLOC_CTX *frame = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + struct spoolss_AddDriverInfo3 *driver; + struct spoolss_AddDriverInfo3 converted_driver; + const char *short_architecture; + struct files_struct *dirfsp = NULL; + struct smb_filename *smb_dname = NULL; + char *new_dir = NULL; + struct conn_struct_tos *c = NULL; + connection_struct *conn = NULL; + NTSTATUS nt_status; + int i; + int ver = 0; + char *printdollar = NULL; + int printdollar_snum; + WERROR err = WERR_OK; + + switch (r->level) { + case 3: + driver = r->info.info3; + break; + case 6: + convert_level_6_to_level3(&converted_driver, r->info.info6); + driver = &converted_driver; + break; + case 8: + convert_level_8_to_level3(&converted_driver, r->info.info8); + driver = &converted_driver; + break; + default: + DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)r->level)); + TALLOC_FREE(frame); + return WERR_INVALID_LEVEL; + } + + short_architecture = get_short_archi(driver->architecture); + if (!short_architecture) { + TALLOC_FREE(frame); + return WERR_UNKNOWN_PRINTER_DRIVER; + } + + printdollar_snum = find_service(frame, "print$", &printdollar); + if (!printdollar) { + TALLOC_FREE(frame); + return WERR_NOT_ENOUGH_MEMORY; + } + if (printdollar_snum == -1) { + TALLOC_FREE(frame); + return WERR_BAD_NET_NAME; + } + + nt_status = create_conn_struct_tos_cwd(global_messaging_context(), + printdollar_snum, + lp_path(frame, lp_sub, printdollar_snum), + session_info, + &c); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0,("move_driver_to_download_area: create_conn_struct " + "returned %s\n", nt_errstr(nt_status))); + err = ntstatus_to_werror(nt_status); + TALLOC_FREE(frame); + return err; + } + conn = c->conn; + + nt_status = set_conn_force_user_group(conn, printdollar_snum); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0, ("failed set force user / group\n")); + err = ntstatus_to_werror(nt_status); + goto err_free_conn; + } + + if (!become_user_without_service_by_session(conn, session_info)) { + DEBUG(0, ("failed to become user\n")); + err = WERR_ACCESS_DENIED; + goto err_free_conn; + } + + new_dir = talloc_asprintf(frame, + "%s/%d", + short_architecture, + driver->version); + if (!new_dir) { + err = WERR_NOT_ENOUGH_MEMORY; + goto err_exit; + } + nt_status = driver_unix_convert(conn, new_dir, &dirfsp, &smb_dname); + if (!NT_STATUS_IS_OK(nt_status)) { + err = WERR_NOT_ENOUGH_MEMORY; + goto err_exit; + } + + DEBUG(5,("Creating first directory: %s\n", smb_dname->base_name)); + + nt_status = create_directory(conn, NULL, dirfsp, smb_dname); + if (!NT_STATUS_IS_OK(nt_status) + && !NT_STATUS_EQUAL(nt_status, NT_STATUS_OBJECT_NAME_COLLISION)) { + DEBUG(0, ("failed to create driver destination directory: %s\n", + nt_errstr(nt_status))); + err = ntstatus_to_werror(nt_status); + goto err_exit; + } + + /* For each driver file, archi\filexxx.yyy, if there is a duplicate file + * listed for this driver which has already been moved, skip it (note: + * drivers may list the same file name several times. Then check if the + * file already exists in archi\version\, if so, check that the version + * info (or time stamps if version info is unavailable) is newer (or the + * date is later). If it is, move it to archi\version\filexxx.yyy. + * Otherwise, delete the file. + * + * If a file is not moved to archi\version\ because of an error, all the + * rest of the 'unmoved' driver files are removed from archi\. If one or + * more of the driver's files was already moved to archi\version\, it + * potentially leaves the driver in a partially updated state. Version + * trauma will most likely occur if an client attempts to use any printer + * bound to the driver. Perhaps a rewrite to make sure the moves can be + * done is appropriate... later JRR + */ + + DEBUG(5,("Moving files now !\n")); + + if (driver->driver_path && strlen(driver->driver_path)) { + + err = move_driver_file_to_download_area(frame, + conn, + driver->driver_path, + short_architecture, + driver->version, + ver, + driver_directory); + if (!W_ERROR_IS_OK(err)) { + goto err_exit; + } + } + + if (driver->data_file && strlen(driver->data_file)) { + if (!strequal(driver->data_file, driver->driver_path)) { + + err = move_driver_file_to_download_area(frame, + conn, + driver->data_file, + short_architecture, + driver->version, + ver, + driver_directory); + if (!W_ERROR_IS_OK(err)) { + goto err_exit; + } + } + } + + if (driver->config_file && strlen(driver->config_file)) { + if (!strequal(driver->config_file, driver->driver_path) && + !strequal(driver->config_file, driver->data_file)) { + + err = move_driver_file_to_download_area(frame, + conn, + driver->config_file, + short_architecture, + driver->version, + ver, + driver_directory); + if (!W_ERROR_IS_OK(err)) { + goto err_exit; + } + } + } + + if (driver->help_file && strlen(driver->help_file)) { + if (!strequal(driver->help_file, driver->driver_path) && + !strequal(driver->help_file, driver->data_file) && + !strequal(driver->help_file, driver->config_file)) { + + err = move_driver_file_to_download_area(frame, + conn, + driver->help_file, + short_architecture, + driver->version, + ver, + driver_directory); + if (!W_ERROR_IS_OK(err)) { + goto err_exit; + } + } + } + + if (driver->dependent_files && driver->dependent_files->string) { + for (i=0; driver->dependent_files->string[i]; i++) { + if (!strequal(driver->dependent_files->string[i], driver->driver_path) && + !strequal(driver->dependent_files->string[i], driver->data_file) && + !strequal(driver->dependent_files->string[i], driver->config_file) && + !strequal(driver->dependent_files->string[i], driver->help_file)) { + int j; + for (j=0; j < i; j++) { + if (strequal(driver->dependent_files->string[i], driver->dependent_files->string[j])) { + goto NextDriver; + } + } + + err = move_driver_file_to_download_area(frame, + conn, + driver->dependent_files->string[i], + short_architecture, + driver->version, + ver, + driver_directory); + if (!W_ERROR_IS_OK(err)) { + goto err_exit; + } + } + NextDriver: ; + } + } + + err = WERR_OK; + err_exit: + unbecome_user_without_service(); + err_free_conn: + TALLOC_FREE(frame); + return err; +} + +/**************************************************************************** + Determine whether or not a particular driver is currently assigned + to a printer +****************************************************************************/ + +bool printer_driver_in_use(TALLOC_CTX *mem_ctx, + struct dcerpc_binding_handle *b, + const struct spoolss_DriverInfo8 *r) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int snum; + int n_services = lp_numservices(); + bool in_use = false; + struct spoolss_PrinterInfo2 *pinfo2 = NULL; + WERROR result; + + if (!r) { + return false; + } + + DEBUG(10,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n")); + + /* loop through the printers.tdb and check for the drivername */ + + for (snum=0; snumdriver_name, pinfo2->drivername)) { + in_use = true; + } + + TALLOC_FREE(pinfo2); + } + + DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n")); + + if ( in_use ) { + struct spoolss_DriverInfo8 *driver = NULL; + WERROR werr; + + DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", r->driver_name)); + + /* we can still remove the driver if there is one of + "Windows NT x86" version 2 or 3 left */ + + if (strequal(SPOOLSS_ARCHITECTURE_NT_X86, r->architecture)) { + if (r->version == 2) { + werr = winreg_get_driver(mem_ctx, b, + r->architecture, + r->driver_name, + 3, &driver); + } else if (r->version == 3) { + werr = winreg_get_driver(mem_ctx, b, + r->architecture, + r->driver_name, + 2, &driver); + } else { + DBG_ERR("Unknown driver version (%d)\n", + r->version); + werr = WERR_UNKNOWN_PRINTER_DRIVER; + } + } else if (strequal(SPOOLSS_ARCHITECTURE_x64, r->architecture)) { + werr = winreg_get_driver(mem_ctx, b, + SPOOLSS_ARCHITECTURE_NT_X86, + r->driver_name, + DRIVER_ANY_VERSION, + &driver); + } else { + DBG_ERR("Unknown driver architecture: %s\n", + r->architecture); + werr = WERR_UNKNOWN_PRINTER_DRIVER; + } + + /* now check the error code */ + + if ( W_ERROR_IS_OK(werr) ) { + /* it's ok to remove the driver, we have other architectures left */ + in_use = false; + talloc_free(driver); + } + } + + /* report that the driver is not in use by default */ + + return in_use; +} + + +/********************************************************************** + Check to see if a ogiven file is in use by *info + *********************************************************************/ + +static bool drv_file_in_use(const char *file, const struct spoolss_DriverInfo8 *info) +{ + int i = 0; + + if ( !info ) + return False; + + /* mz: skip files that are in the list but already deleted */ + if (!file || !file[0]) { + return false; + } + + if (strequal(file, info->driver_path)) + return True; + + if (strequal(file, info->data_file)) + return True; + + if (strequal(file, info->config_file)) + return True; + + if (strequal(file, info->help_file)) + return True; + + /* see of there are any dependent files to examine */ + + if (!info->dependent_files) + return False; + + while (info->dependent_files[i] && *info->dependent_files[i]) { + if (strequal(file, info->dependent_files[i])) + return True; + i++; + } + + return False; + +} + +/********************************************************************** + Utility function to remove the dependent file pointed to by the + input parameter from the list + *********************************************************************/ + +static void trim_dependent_file(TALLOC_CTX *mem_ctx, const char **files, int idx) +{ + + /* bump everything down a slot */ + + while (files && files[idx+1]) { + files[idx] = talloc_strdup(mem_ctx, files[idx+1]); + idx++; + } + + files[idx] = NULL; + + return; +} + +/********************************************************************** + Check if any of the files used by src are also used by drv + *********************************************************************/ + +static bool trim_overlap_drv_files(TALLOC_CTX *mem_ctx, + struct spoolss_DriverInfo8 *src, + const struct spoolss_DriverInfo8 *drv) +{ + bool in_use = False; + int i = 0; + + if ( !src || !drv ) + return False; + + /* check each file. Remove it from the src structure if it overlaps */ + + if (drv_file_in_use(src->driver_path, drv)) { + in_use = True; + DEBUG(10,("Removing driverfile [%s] from list\n", src->driver_path)); + src->driver_path = talloc_strdup(mem_ctx, ""); + if (!src->driver_path) { return false; } + } + + if (drv_file_in_use(src->data_file, drv)) { + in_use = True; + DEBUG(10,("Removing datafile [%s] from list\n", src->data_file)); + src->data_file = talloc_strdup(mem_ctx, ""); + if (!src->data_file) { return false; } + } + + if (drv_file_in_use(src->config_file, drv)) { + in_use = True; + DEBUG(10,("Removing configfile [%s] from list\n", src->config_file)); + src->config_file = talloc_strdup(mem_ctx, ""); + if (!src->config_file) { return false; } + } + + if (drv_file_in_use(src->help_file, drv)) { + in_use = True; + DEBUG(10,("Removing helpfile [%s] from list\n", src->help_file)); + src->help_file = talloc_strdup(mem_ctx, ""); + if (!src->help_file) { return false; } + } + + /* are there any dependentfiles to examine? */ + + if (!src->dependent_files) + return in_use; + + while (src->dependent_files[i] && *src->dependent_files[i]) { + if (drv_file_in_use(src->dependent_files[i], drv)) { + in_use = True; + DEBUG(10,("Removing [%s] from dependent file list\n", src->dependent_files[i])); + trim_dependent_file(mem_ctx, src->dependent_files, i); + } else + i++; + } + + return in_use; +} + +/**************************************************************************** + Determine whether or not a particular driver files are currently being + used by any other driver. + + Return value is True if any files were in use by other drivers + and False otherwise. + + Upon return, *info has been modified to only contain the driver files + which are not in use + + Fix from mz: + + This needs to check all drivers to ensure that all files in use + have been removed from *info, not just the ones in the first + match. +****************************************************************************/ + +bool printer_driver_files_in_use(TALLOC_CTX *mem_ctx, + struct dcerpc_binding_handle *b, + struct spoolss_DriverInfo8 *info) +{ + uint32_t version; + struct spoolss_DriverInfo8 *driver; + bool in_use = false; + uint32_t i, num_drivers; + const char **drivers; + WERROR result; + + if ( !info ) + return False; + + version = info->version; + + /* loop over all driver versions */ + + DEBUG(5,("printer_driver_files_in_use: Beginning search of drivers...\n")); + + /* get the list of drivers */ + + result = winreg_get_driver_list(mem_ctx, b, + info->architecture, version, + &num_drivers, &drivers); + if (!W_ERROR_IS_OK(result)) { + return true; + } + + DEBUGADD(4, ("we have:[%d] drivers in environment [%s] and version [%d]\n", + num_drivers, info->architecture, version)); + + /* check each driver for overlap in files */ + + for (i = 0; i < num_drivers; i++) { + DEBUGADD(5,("\tdriver: [%s]\n", drivers[i])); + + driver = NULL; + + result = winreg_get_driver(mem_ctx, b, + info->architecture, drivers[i], + version, &driver); + if (!W_ERROR_IS_OK(result)) { + talloc_free(drivers); + return True; + } + + /* check if d2 uses any files from d1 */ + /* only if this is a different driver than the one being deleted */ + + if (!strequal(info->driver_name, driver->driver_name)) { + if (trim_overlap_drv_files(mem_ctx, info, driver)) { + /* mz: Do not instantly return - + * we need to ensure this file isn't + * also in use by other drivers. */ + in_use = true; + } + } + + talloc_free(driver); + } + + talloc_free(drivers); + + DEBUG(5,("printer_driver_files_in_use: Completed search of drivers...\n")); + + return in_use; +} + +static NTSTATUS driver_unlink_internals(connection_struct *conn, + const char *short_arch, + int vers, + const char *fname) +{ + TALLOC_CTX *tmp_ctx = talloc_new(conn); + struct smb_filename *smb_fname = NULL; + char *print_dlr_path; + NTSTATUS status = NT_STATUS_NO_MEMORY; + + print_dlr_path = talloc_asprintf(tmp_ctx, "%s/%d/%s", + short_arch, vers, fname); + if (print_dlr_path == NULL) { + goto err_out; + } + + status = synthetic_pathref(tmp_ctx, + conn->cwd_fsp, + print_dlr_path, + NULL, + NULL, + 0, + 0, + &smb_fname); + if (!NT_STATUS_IS_OK(status)) { + goto err_out; + } + + status = unlink_internals(conn, NULL, 0, NULL, smb_fname); +err_out: + talloc_free(tmp_ctx); + return status; +} + +/**************************************************************************** + Actually delete the driver files. Make sure that + printer_driver_files_in_use() return False before calling + this. +****************************************************************************/ + +bool delete_driver_files(const struct auth_session_info *session_info, + const struct spoolss_DriverInfo8 *r) +{ + TALLOC_CTX *frame = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *short_arch; + struct conn_struct_tos *c = NULL; + connection_struct *conn = NULL; + NTSTATUS nt_status; + char *printdollar = NULL; + int printdollar_snum; + bool ret = false; + + if (!r) { + TALLOC_FREE(frame); + return false; + } + + DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", + r->driver_name, r->version)); + + printdollar_snum = find_service(frame, "print$", &printdollar); + if (!printdollar) { + TALLOC_FREE(frame); + return false; + } + if (printdollar_snum == -1) { + TALLOC_FREE(frame); + return false; + } + + nt_status = create_conn_struct_tos_cwd(global_messaging_context(), + printdollar_snum, + lp_path(frame, lp_sub, printdollar_snum), + session_info, + &c); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0,("delete_driver_files: create_conn_struct " + "returned %s\n", nt_errstr(nt_status))); + TALLOC_FREE(frame); + return false; + } + conn = c->conn; + + nt_status = set_conn_force_user_group(conn, printdollar_snum); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0, ("failed set force user / group\n")); + ret = false; + goto err_free_conn; + } + + if (!become_user_without_service_by_session(conn, session_info)) { + DEBUG(0, ("failed to become user\n")); + ret = false; + goto err_free_conn; + } + + if ( !CAN_WRITE(conn) ) { + DEBUG(3,("delete_driver_files: Cannot delete print driver when [print$] is read-only\n")); + ret = false; + goto err_out; + } + + short_arch = get_short_archi(r->architecture); + if (short_arch == NULL) { + DEBUG(0, ("bad architecture %s\n", r->architecture)); + ret = false; + goto err_out; + } + + /* now delete the files */ + + if (r->driver_path && r->driver_path[0]) { + DEBUG(10,("deleting driverfile [%s]\n", r->driver_path)); + driver_unlink_internals(conn, short_arch, r->version, r->driver_path); + } + + if (r->config_file && r->config_file[0]) { + DEBUG(10,("deleting configfile [%s]\n", r->config_file)); + driver_unlink_internals(conn, short_arch, r->version, r->config_file); + } + + if (r->data_file && r->data_file[0]) { + DEBUG(10,("deleting datafile [%s]\n", r->data_file)); + driver_unlink_internals(conn, short_arch, r->version, r->data_file); + } + + if (r->help_file && r->help_file[0]) { + DEBUG(10,("deleting helpfile [%s]\n", r->help_file)); + driver_unlink_internals(conn, short_arch, r->version, r->help_file); + } + + if (r->dependent_files) { + int i = 0; + while (r->dependent_files[i] && r->dependent_files[i][0]) { + DEBUG(10,("deleting dependent file [%s]\n", r->dependent_files[i])); + driver_unlink_internals(conn, short_arch, r->version, r->dependent_files[i]); + i++; + } + } + + ret = true; + err_out: + unbecome_user_without_service(); + err_free_conn: + TALLOC_FREE(frame); + return ret; +} + +/* error code: + 0: everything OK + 1: level not implemented + 2: file doesn't exist + 3: can't allocate memory + 4: can't free memory + 5: non existent struct +*/ + +/* + A printer and a printer driver are 2 different things. + NT manages them separately, Samba does the same. + Why ? Simply because it's easier and it makes sense ! + + Now explanation: You have 3 printers behind your samba server, + 2 of them are the same make and model (laser A and B). But laser B + has an 3000 sheet feeder and laser A doesn't such an option. + Your third printer is an old dot-matrix model for the accounting :-). + + If the /usr/local/samba/lib directory (default dir), you will have + 5 files to describe all of this. + + 3 files for the printers (1 by printer): + NTprinter_laser A + NTprinter_laser B + NTprinter_accounting + 2 files for the drivers (1 for the laser and 1 for the dot matrix) + NTdriver_printer model X + NTdriver_printer model Y + +jfm: I should use this comment for the text file to explain + same thing for the forms BTW. + Je devrais mettre mes commentaires en francais, ca serait mieux :-) + +*/ + +/* Convert generic access rights to printer object specific access rights. + It turns out that NT4 security descriptors use generic access rights and + NT5 the object specific ones. */ + +void map_printer_permissions(struct security_descriptor *sd) +{ + uint32_t i; + + for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) { + se_map_generic(&sd->dacl->aces[i].access_mask, + &printer_generic_mapping); + } +} + +void map_job_permissions(struct security_descriptor *sd) +{ + uint32_t i; + + for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) { + se_map_generic(&sd->dacl->aces[i].access_mask, + &job_generic_mapping); + } +} + + +/**************************************************************************** + Check a user has permissions to perform the given operation. We use the + permission constants defined in include/rpc_spoolss.h to check the various + actions we perform when checking printer access. + + PRINTER_ACCESS_ADMINISTER: + print_queue_pause, print_queue_resume, update_printer_sec, + update_printer, spoolss_addprinterex_level_2, + _spoolss_setprinterdata + + PRINTER_ACCESS_USE: + print_job_start + + JOB_ACCESS_ADMINISTER: + print_job_delete, print_job_pause, print_job_resume, + print_queue_purge + + Try access control in the following order (for performance reasons): + 1) root and SE_PRINT_OPERATOR can do anything (easy check) + 2) check security descriptor (bit comparisons in memory) + 3) "printer admins" (may result in numerous calls to winbind) + + ****************************************************************************/ +WERROR print_access_check(const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, int snum, + int access_type) +{ + struct spoolss_security_descriptor *secdesc = NULL; + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + uint32_t access_granted; + size_t sd_size; + NTSTATUS status; + WERROR result; + const char *pname; + TALLOC_CTX *mem_ctx = NULL; + + /* If user is NULL then use the current_user structure */ + + /* Always allow root or SE_PRINT_OPERATROR to do anything */ + + if ((session_info->unix_token->uid == sec_initial_uid()) + || security_token_has_privilege(session_info->security_token, + SEC_PRIV_PRINT_OPERATOR)) { + return WERR_OK; + } + + /* Get printer name */ + + pname = lp_printername(talloc_tos(), lp_sub, snum); + + if (!pname || !*pname) { + return WERR_ACCESS_DENIED; + } + + /* Get printer security descriptor */ + + if(!(mem_ctx = talloc_init("print_access_check"))) { + return WERR_NOT_ENOUGH_MEMORY; + } + + result = winreg_get_printer_secdesc_internal(mem_ctx, + get_session_info_system(), + msg_ctx, + pname, + &secdesc); + if (!W_ERROR_IS_OK(result)) { + talloc_destroy(mem_ctx); + return WERR_NOT_ENOUGH_MEMORY; + } + + if (access_type == JOB_ACCESS_ADMINISTER) { + struct spoolss_security_descriptor *parent_secdesc = secdesc; + + /* Create a child security descriptor to check permissions + against. This is because print jobs are child objects + objects of a printer. */ + status = se_create_child_secdesc(mem_ctx, + &secdesc, + &sd_size, + parent_secdesc, + parent_secdesc->owner_sid, + parent_secdesc->group_sid, + false); + if (!NT_STATUS_IS_OK(status)) { + talloc_destroy(mem_ctx); + return ntstatus_to_werror(status); + } + + map_job_permissions(secdesc); + } else { + map_printer_permissions(secdesc); + } + + /* Check access */ + status = se_access_check(secdesc, session_info->security_token, access_type, + &access_granted); + + DEBUG(4, ("access check was %s\n", NT_STATUS_IS_OK(status) ? "SUCCESS" : "FAILURE")); + + talloc_destroy(mem_ctx); + + return ntstatus_to_werror(status); +} + +/**************************************************************************** + Check the time parameters allow a print operation. +*****************************************************************************/ + +bool print_time_access_check(const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *servicename) +{ + struct spoolss_PrinterInfo2 *pinfo2 = NULL; + WERROR result; + bool ok = False; + time_t now = time(NULL); + struct tm *t; + uint32_t mins; + + result = winreg_get_printer_internal(NULL, session_info, msg_ctx, + servicename, &pinfo2); + if (!W_ERROR_IS_OK(result)) { + return False; + } + + if (pinfo2->starttime == 0 && pinfo2->untiltime == 0) { + ok = True; + } + + t = gmtime(&now); + mins = (uint32_t)t->tm_hour*60 + (uint32_t)t->tm_min; + + if (mins >= pinfo2->starttime && mins <= pinfo2->untiltime) { + ok = True; + } + + TALLOC_FREE(pinfo2); + + if (!ok) { + errno = EACCES; + } + + return ok; +} + +void nt_printer_remove(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *printer) +{ + WERROR result; + + result = winreg_delete_printer_key_internal(mem_ctx, session_info, msg_ctx, + printer, ""); + if (!W_ERROR_IS_OK(result)) { + DEBUG(0, ("nt_printer_remove: failed to remove printer %s: " + "%s\n", printer, win_errstr(result))); + } +} + +void nt_printer_add(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *printer) +{ + WERROR result; + + result = winreg_create_printer_internal(mem_ctx, session_info, msg_ctx, + printer); + if (!W_ERROR_IS_OK(result)) { + DEBUG(0, ("nt_printer_add: failed to add printer %s: %s\n", + printer, win_errstr(result))); + } +} diff --git a/source3/printing/nt_printing_ads.c b/source3/printing/nt_printing_ads.c new file mode 100644 index 0000000..4d5991e --- /dev/null +++ b/source3/printing/nt_printing_ads.c @@ -0,0 +1,908 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (C) Andrew Tridgell 1992-2000, + * Copyright (C) Jean François Micouleau 1998-2000. + * Copyright (C) Gerald Carter 2002-2005. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "../librpc/gen_ndr/spoolss.h" +#include "rpc_server/spoolss/srv_spoolss_util.h" +#include "nt_printing.h" +#include "ads.h" +#include "secrets.h" +#include "krb5_env.h" +#include "../libcli/registry/util_reg.h" +#include "auth.h" +#include "../librpc/ndr/libndr.h" +#include "rpc_client/cli_winreg_spoolss.h" + +#ifdef HAVE_ADS +/***************************************************************** + ****************************************************************/ + +WERROR nt_printer_guid_store(struct messaging_context *msg_ctx, + const char *printer, struct GUID guid) +{ + TALLOC_CTX *tmp_ctx; + const struct auth_session_info *session_info; + const char *guid_str; + DATA_BLOB blob; + WERROR result; + + tmp_ctx = talloc_new(NULL); + if (!tmp_ctx) { + DEBUG(0, ("Out of memory?!\n")); + return WERR_NOT_ENOUGH_MEMORY; + } + + session_info = get_session_info_system(); + if (session_info == NULL) { + DEBUG(0, ("Could not get system session_info\n")); + result = WERR_NOT_ENOUGH_MEMORY; + goto done; + } + + guid_str = GUID_string(tmp_ctx, &guid); + if (!guid_str) { + DEBUG(0, ("Out of memory?!\n")); + result = WERR_NOT_ENOUGH_MEMORY; + goto done; + } + + /* We used to store this as a REG_BINARY but that causes + Vista to whine */ + + if (!push_reg_sz(tmp_ctx, &blob, guid_str)) { + DEBUG(0, ("Could not marshall string %s for objectGUID\n", + guid_str)); + result = WERR_NOT_ENOUGH_MEMORY; + goto done; + } + + result = winreg_set_printer_dataex_internal(tmp_ctx, session_info, msg_ctx, + printer, + SPOOL_DSSPOOLER_KEY, "objectGUID", + REG_SZ, blob.data, blob.length); + if (!W_ERROR_IS_OK(result)) { + DEBUG(0, ("Failed to store GUID for printer %s\n", printer)); + goto done; + } + + result = WERR_OK; +done: + talloc_free(tmp_ctx); + + return result; +} + +static WERROR nt_printer_dn_lookup(TALLOC_CTX *mem_ctx, + ADS_STRUCT *ads, + const char *printer, + char **pprinter_dn) +{ + char *printer_dn = NULL; + char *srv_dn = NULL; + char *srv_cn_0 = NULL; + char *srv_cn_escaped = NULL; + char *sharename_escaped = NULL; + char *srv_dn_utf8 = NULL; + char **srv_cn_utf8 = NULL; + size_t converted_size; + ADS_STATUS ads_status; + LDAPMessage *res; + WERROR result; + bool ok; + + ads_status = ads_find_machine_acct(ads, &res, lp_netbios_name()); + if (!ADS_ERR_OK(ads_status)) { + DEBUG(2, ("Failed to find machine account for %s\n", + lp_netbios_name())); + result = WERR_NOT_FOUND; + goto err_out; + } + + /* + * We use ldap_get_dn here as we need the answer in utf8 to call + * ldap_explode_dn(). JRA. + */ + srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res); + ads_msgfree(ads, res); + if (srv_dn_utf8 == NULL) { + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto err_out; + } + + srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1); + if (srv_cn_utf8 == NULL) { + ldap_memfree(srv_dn_utf8); + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto err_out; + } + + /* Now convert to CH_UNIX. */ + ok = pull_utf8_talloc(mem_ctx, &srv_dn, srv_dn_utf8, &converted_size); + ldap_memfree(srv_dn_utf8); + if (!ok) { + ldap_memfree(srv_cn_utf8); + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto err_out; + } + + ok = pull_utf8_talloc(mem_ctx, &srv_cn_0, srv_cn_utf8[0], &converted_size); + ldap_memfree(srv_cn_utf8); + if (!ok) { + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto err_out; + } + + srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0); + if (srv_cn_escaped == NULL) { + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto err_out; + } + + sharename_escaped = escape_rdn_val_string_alloc(printer); + if (sharename_escaped == NULL) { + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto err_out; + } + + printer_dn = talloc_asprintf(mem_ctx, + "cn=%s-%s,%s", + srv_cn_escaped, + sharename_escaped, + srv_dn); + if (printer_dn == NULL) { + result = WERR_NOT_ENOUGH_MEMORY; + goto err_out; + } + + *pprinter_dn = printer_dn; + + result = WERR_OK; +err_out: + SAFE_FREE(sharename_escaped); + SAFE_FREE(srv_cn_escaped); + TALLOC_FREE(srv_cn_0); + TALLOC_FREE(srv_dn); + return result; +} + +static WERROR nt_printer_guid_retrieve_internal(ADS_STRUCT *ads, + const char *printer_dn, + struct GUID *pguid) +{ + ADS_STATUS ads_status; + LDAPMessage *res; + const char *attrs[] = {"objectGUID", NULL}; + struct GUID guid; + bool ok; + + ads_status = ads_search_dn(ads, &res, printer_dn, attrs); + if (!ADS_ERR_OK(ads_status)) { + DEBUG(2, ("Failed to retrieve GUID from DC - %s\n", + ads_errstr(ads_status))); + return WERR_FILE_NOT_FOUND; + } + + ZERO_STRUCT(guid); + ok = ads_pull_guid(ads, res, &guid); + ads_msgfree(ads, res); + if (!ok) { + return WERR_NOT_ENOUGH_MEMORY; + } + + *pguid = guid; + + return WERR_OK; +} + +WERROR nt_printer_guid_retrieve(TALLOC_CTX *mem_ctx, const char *printer, + struct GUID *pguid) +{ + ADS_STRUCT *ads = NULL; + char *old_krb5ccname = NULL; + char *printer_dn; + WERROR result; + ADS_STATUS ads_status; + TALLOC_CTX *tmp_ctx = talloc_stackframe(); + char *machine_password = NULL; + + ads = ads_init(tmp_ctx, + lp_realm(), + lp_workgroup(), + NULL, + ADS_SASL_PLAIN); + if (ads == NULL) { + result = WERR_RPC_S_SERVER_UNAVAILABLE; + goto out; + } + + old_krb5ccname = getenv(KRB5_ENV_CCNAME); + setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1); + ADS_TALLOC_CONST_FREE(ads->auth.password); + machine_password = secrets_fetch_machine_password(lp_workgroup(), + NULL, NULL); + if (machine_password != NULL) { + ads->auth.password = talloc_strdup(ads, machine_password); + SAFE_FREE(machine_password); + if (ads->auth.password == NULL) { + result = WERR_NOT_ENOUGH_MEMORY; + goto out; + } + } + + ads_status = ads_connect(ads); + if (!ADS_ERR_OK(ads_status)) { + DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_status))); + result = WERR_ACCESS_DENIED; + goto out; + } + + result = nt_printer_dn_lookup(tmp_ctx, ads, printer, &printer_dn); + if (!W_ERROR_IS_OK(result)) { + goto out; + } + + result = nt_printer_guid_retrieve_internal(ads, printer_dn, pguid); +out: + TALLOC_FREE(tmp_ctx); + ads_kdestroy("MEMORY:prtpub_cache"); + unsetenv(KRB5_ENV_CCNAME); + if (old_krb5ccname != NULL) { + setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0); + } + + return result; +} + +WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *printer, struct GUID *guid) +{ + TALLOC_CTX *tmp_ctx; + enum winreg_Type type; + DATA_BLOB blob; + uint32_t len; + NTSTATUS status; + WERROR result; + + tmp_ctx = talloc_new(mem_ctx); + if (tmp_ctx == NULL) { + DEBUG(0, ("out of memory?!\n")); + return WERR_NOT_ENOUGH_MEMORY; + } + + result = winreg_get_printer_dataex_internal(tmp_ctx, session_info, + msg_ctx, printer, + SPOOL_DSSPOOLER_KEY, + "objectGUID", + &type, + &blob.data, + &len); + if (!W_ERROR_IS_OK(result)) { + DEBUG(0, ("Failed to get GUID for printer %s\n", printer)); + goto out_ctx_free; + } + blob.length = (size_t)len; + + /* We used to store the guid as REG_BINARY, then swapped + to REG_SZ for Vista compatibility so check for both */ + + switch (type) { + case REG_SZ: { + bool ok; + const char *guid_str; + ok = pull_reg_sz(tmp_ctx, &blob, &guid_str); + if (!ok) { + DEBUG(0, ("Failed to unmarshall GUID for printer %s\n", + printer)); + result = WERR_REGISTRY_CORRUPT; + goto out_ctx_free; + } + status = GUID_from_string(guid_str, guid); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("bad GUID for printer %s\n", printer)); + result = ntstatus_to_werror(status); + goto out_ctx_free; + } + break; + } + case REG_BINARY: + if (blob.length != sizeof(struct GUID)) { + DEBUG(0, ("bad GUID for printer %s\n", printer)); + result = WERR_REGISTRY_CORRUPT; + goto out_ctx_free; + } + memcpy(guid, blob.data, sizeof(struct GUID)); + break; + default: + DEBUG(0,("GUID value stored as invalid type (%d)\n", type)); + result = WERR_REGISTRY_CORRUPT; + goto out_ctx_free; + break; + } + result = WERR_OK; + +out_ctx_free: + talloc_free(tmp_ctx); + return result; +} + +static WERROR nt_printer_devmode_to_mods(TALLOC_CTX *ctx, + struct spoolss_DeviceMode *devmode, + ADS_MODLIST *mods) +{ + char *str = NULL; + ADS_STATUS status; + + /* + the device mode fields bits allow us to make an educated guess if a + printer feature is supported. For sure a feature must be unsupported if + the fields bit is not set. Device Mode Extra Data and FeatureOptionPairs + might help to figure out more information here. Common attributes, that + we can't handle yet: + SPOOL_REG_PRINTBINNAMES - printBinNames + SPOOL_REG_PRINTMAXXEXTENT - printMaxXExtent + SPOOL_REG_PRINTMAXYEXTENT - printMaxYExtent + SPOOL_REG_PRINTMINXEXTENT - printMinXExtent + SPOOL_REG_PRINTMINYEXTENT - printMinYExtent + SPOOL_REG_PRINTSTAPLINGSUPPORTED - printStaplingSupported + SPOOL_REG_PRINTPAGESPERMINUTE - printPagesPerMinute + SPOOL_REG_PRINTRATE - printRate + SPOOL_REG_PRINTRATEUNIT - printRateUnit + SPOOL_REG_PRINTMEDIAREADY - printMediaReady + SPOOL_REG_PRINTMEDIASUPPORTED - printMediaSupported + SPOOL_REG_PRINTNUMBERUP - printNumberUp + SPOOL_REG_PRINTMAXCOPIES - printMaxCopies + */ + if (devmode->fields & DEVMODE_COLOR) { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTCOLOR, "TRUE"); + } else { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTCOLOR, "FALSE"); + } + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + + if (devmode->fields & DEVMODE_DUPLEX) { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTDUPLEXSUPPORTED, "TRUE"); + } else { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTDUPLEXSUPPORTED, "FALSE"); + } + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + + if (devmode->fields & DEVMODE_COLLATE) { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTCOLLATE, "TRUE"); + } else { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTCOLLATE, "FALSE"); + } + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + + /* portrait mode is always supported, LANDSCAPE is optional */ + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTORIENTATIONSSUPPORTED, "PORTRAIT"); + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + if (devmode->fields & DEVMODE_ORIENTATION) { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTORIENTATIONSSUPPORTED, "LANDSCAPE"); + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + } + + /* the driverVersion attribute in AD contains actually specversion */ + str = talloc_asprintf(ctx, "%u", devmode->specversion); + if (str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + if (strlen(str) != 0) { + status = ads_mod_str(ctx, mods, SPOOL_REG_DRIVERVERSION, str); + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + } + + /* devmode->yresolution is a good candidate for printMaxResolutionSupported */ + str = talloc_asprintf(ctx, "%u", devmode->yresolution); + if (str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + if (strlen(str) != 0) { + status = ads_mod_str(ctx, mods, SPOOL_REG_PRINTMAXRESOLUTIONSUPPORTED, str); + if (!ADS_ERR_OK(status)) { + return WERR_NOT_ENOUGH_MEMORY; + } + } + + return WERR_OK; +} + + + +static WERROR nt_printer_info_to_mods(TALLOC_CTX *ctx, + struct spoolss_PrinterInfo2 *info2, + ADS_MODLIST *mods) +{ + char *info_str; + + ads_mod_str(ctx, mods, SPOOL_REG_PRINTERNAME, info2->sharename); + ads_mod_str(ctx, mods, SPOOL_REG_PRINTSHARENAME, info2->sharename); + ads_mod_str(ctx, mods, SPOOL_REG_SHORTSERVERNAME, lp_netbios_name()); + ads_mod_str(ctx, mods, SPOOL_REG_SERVERNAME, get_mydnsfullname()); + + info_str = talloc_asprintf(ctx, "\\\\%s\\%s", + get_mydnsfullname(), info2->sharename); + if (info_str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + ads_mod_str(ctx, mods, SPOOL_REG_UNCNAME, info_str); + + info_str = talloc_asprintf(ctx, "%d", 4); + if (info_str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + ads_mod_str(ctx, mods, SPOOL_REG_VERSIONNUMBER, info_str); + + /* empty strings in the mods list result in an attribute error */ + if (strlen(info2->drivername) != 0) + ads_mod_str(ctx, mods, SPOOL_REG_DRIVERNAME, info2->drivername); + if (strlen(info2->location) != 0) + ads_mod_str(ctx, mods, SPOOL_REG_LOCATION, info2->location); + if (strlen(info2->comment) != 0) + ads_mod_str(ctx, mods, SPOOL_REG_DESCRIPTION, info2->comment); + if (strlen(info2->portname) != 0) + ads_mod_str(ctx, mods, SPOOL_REG_PORTNAME, info2->portname); + if (strlen(info2->sepfile) != 0) + ads_mod_str(ctx, mods, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile); + + info_str = talloc_asprintf(ctx, "%u", info2->starttime); + if (info_str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + ads_mod_str(ctx, mods, SPOOL_REG_PRINTSTARTTIME, info_str); + + info_str = talloc_asprintf(ctx, "%u", info2->untiltime); + if (info_str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + ads_mod_str(ctx, mods, SPOOL_REG_PRINTENDTIME, info_str); + + info_str = talloc_asprintf(ctx, "%u", info2->priority); + if (info_str == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + ads_mod_str(ctx, mods, SPOOL_REG_PRIORITY, info_str); + + if (info2->attributes & PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS) { + ads_mod_str(ctx, mods, SPOOL_REG_PRINTKEEPPRINTEDJOBS, "TRUE"); + } else { + ads_mod_str(ctx, mods, SPOOL_REG_PRINTKEEPPRINTEDJOBS, "FALSE"); + } + + switch (info2->attributes & 0x3) { + case 0: + ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING, + SPOOL_REGVAL_PRINTWHILESPOOLING); + break; + case 1: + ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING, + SPOOL_REGVAL_PRINTAFTERSPOOLED); + break; + case 2: + ads_mod_str(ctx, mods, SPOOL_REG_PRINTSPOOLING, + SPOOL_REGVAL_PRINTDIRECT); + break; + default: + DEBUG(3, ("unsupported printer attributes %x\n", + info2->attributes)); + } + + if (info2->devmode != NULL) { + WERROR werr; + werr = nt_printer_devmode_to_mods(ctx, info2->devmode, mods); + if (!W_ERROR_IS_OK(werr)) { + return werr; + } + } + + return WERR_OK; +} + +static WERROR nt_printer_publish_ads(struct messaging_context *msg_ctx, + ADS_STRUCT *ads, + struct spoolss_PrinterInfo2 *pinfo2) +{ + ADS_STATUS ads_rc; + TALLOC_CTX *ctx = talloc_stackframe(); + ADS_MODLIST mods; + struct GUID guid; + WERROR win_rc = WERR_OK; + const char *printer = pinfo2->sharename; + char *printer_dn = NULL; + + /* build the ads mods */ + DEBUG(5, ("publishing printer %s\n", printer)); + + win_rc = nt_printer_dn_lookup(ctx, ads, printer, &printer_dn); + if (!W_ERROR_IS_OK(win_rc)) { + DEBUG(2, ("Failed to create printer dn\n")); + TALLOC_FREE(ctx); + return win_rc; + } + + mods = ads_init_mods(ctx); + + if (mods == NULL) { + TALLOC_FREE(ctx); + return WERR_NOT_ENOUGH_MEMORY; + } + + win_rc = nt_printer_info_to_mods(ctx, pinfo2, &mods); + if (!W_ERROR_IS_OK(win_rc)) { + TALLOC_FREE(ctx); + return win_rc; + } + + /* publish it */ + ads_rc = ads_mod_printer_entry(ads, printer_dn, ctx, &mods); + if (ads_rc.err.rc == LDAP_NO_SUCH_OBJECT) { + int i; + for (i=0; mods[i] != 0; i++) + ; + mods[i] = (LDAPMod *)-1; + ads_rc = ads_add_printer_entry(ads, printer_dn, ctx, &mods); + } + + if (!ADS_ERR_OK(ads_rc)) { + DEBUG(3, ("error publishing %s: %s\n", + printer, ads_errstr(ads_rc))); + /* XXX failed to publish, so no guid to retrieve */ + } + + win_rc = nt_printer_guid_retrieve_internal(ads, printer_dn, &guid); + if (!W_ERROR_IS_OK(win_rc)) { + TALLOC_FREE(ctx); + return win_rc; + } + + win_rc = nt_printer_guid_store(msg_ctx, printer, guid); + if (!W_ERROR_IS_OK(win_rc)) { + DEBUG(3, ("failed to store printer %s guid\n", + printer)); + /* not catastrophic, retrieve on next use */ + win_rc = WERR_OK; + } + + TALLOC_FREE(ctx); + + return win_rc; +} + +static WERROR nt_printer_unpublish_ads(ADS_STRUCT *ads, + const char *printer) +{ + ADS_STATUS ads_rc; + LDAPMessage *res = NULL; + char *prt_dn = NULL; + + DEBUG(5, ("unpublishing printer %s\n", printer)); + + /* remove the printer from the directory */ + ads_rc = ads_find_printer_on_server(ads, &res, + printer, lp_netbios_name()); + + if (ADS_ERR_OK(ads_rc) && res && ads_count_replies(ads, res)) { + prt_dn = ads_get_dn(ads, talloc_tos(), res); + if (!prt_dn) { + ads_msgfree(ads, res); + return WERR_NOT_ENOUGH_MEMORY; + } + ads_rc = ads_del_dn(ads, prt_dn); + TALLOC_FREE(prt_dn); + } + + if (res) { + ads_msgfree(ads, res); + } + return WERR_OK; +} + +/**************************************************************************** + * Publish a printer in the directory + * + * @param mem_ctx memory context + * @param session_info session_info to access winreg pipe + * @param pinfo2 printer information + * @param action publish/unpublish action + * @return WERROR indicating status of publishing + ***************************************************************************/ + +WERROR nt_printer_publish(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + struct spoolss_PrinterInfo2 *pinfo2, + int action) +{ + TALLOC_CTX *tmp_ctx = talloc_stackframe(); + uint32_t info2_mask = SPOOLSS_PRINTER_INFO_ATTRIBUTES; + struct spoolss_SetPrinterInfo2 *sinfo2; + ADS_STATUS ads_rc; + ADS_STRUCT *ads = NULL; + WERROR win_rc; + char *old_krb5ccname = NULL; + char *machine_password = NULL; + + sinfo2 = talloc_zero(tmp_ctx, struct spoolss_SetPrinterInfo2); + if (!sinfo2) { + win_rc = WERR_NOT_ENOUGH_MEMORY; + goto done; + } + + switch (action) { + case DSPRINT_PUBLISH: + case DSPRINT_UPDATE: + pinfo2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED; + break; + case DSPRINT_UNPUBLISH: + pinfo2->attributes &= (~PRINTER_ATTRIBUTE_PUBLISHED); + break; + default: + win_rc = WERR_NOT_SUPPORTED; + goto done; + } + + sinfo2->attributes = pinfo2->attributes; + + win_rc = winreg_update_printer_internal(tmp_ctx, session_info, msg_ctx, + pinfo2->sharename, info2_mask, + sinfo2, NULL, NULL); + if (!W_ERROR_IS_OK(win_rc)) { + DBG_NOTICE("Failed to update data for printer [%s] - %s\n", + pinfo2->sharename, + win_errstr(win_rc)); + goto done; + } + + TALLOC_FREE(sinfo2); + + ads = ads_init(tmp_ctx, + lp_realm(), + lp_workgroup(), + NULL, + ADS_SASL_PLAIN); + if (!ads) { + DEBUG(3, ("ads_init() failed\n")); + win_rc = WERR_RPC_S_SERVER_UNAVAILABLE; + goto done; + } + old_krb5ccname = getenv(KRB5_ENV_CCNAME); + setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1); + ADS_TALLOC_CONST_FREE(ads->auth.password); + machine_password = secrets_fetch_machine_password(lp_workgroup(), + NULL, NULL); + if (machine_password != NULL) { + ads->auth.password = talloc_strdup(ads, machine_password); + SAFE_FREE(machine_password); + if (ads->auth.password == NULL) { + win_rc = WERR_NOT_ENOUGH_MEMORY; + goto done; + } + } + + /* ads_connect() will find the DC for us */ + ads_rc = ads_connect(ads); + if (!ADS_ERR_OK(ads_rc)) { + DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc))); + win_rc = WERR_ACCESS_DENIED; + goto done; + } + + switch (action) { + case DSPRINT_PUBLISH: + case DSPRINT_UPDATE: + win_rc = nt_printer_publish_ads(msg_ctx, ads, pinfo2); + break; + case DSPRINT_UNPUBLISH: + win_rc = nt_printer_unpublish_ads(ads, pinfo2->sharename); + break; + } + +done: + ads_kdestroy("MEMORY:prtpub_cache"); + unsetenv(KRB5_ENV_CCNAME); + if (old_krb5ccname) { + setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0); + } + + TALLOC_FREE(tmp_ctx); + + return win_rc; +} + +WERROR check_published_printers(struct messaging_context *msg_ctx) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + ADS_STATUS ads_rc; + ADS_STRUCT *ads = NULL; + int snum; + int n_services = lp_numservices(); + TALLOC_CTX *tmp_ctx = talloc_stackframe(); + struct auth_session_info *session_info = NULL; + struct spoolss_PrinterInfo2 *pinfo2; + NTSTATUS status; + WERROR result; + char *old_krb5ccname = NULL; + char *machine_password = NULL; + + ads = ads_init(tmp_ctx, + lp_realm(), + lp_workgroup(), + NULL, + ADS_SASL_PLAIN); + if (!ads) { + DEBUG(3, ("ads_init() failed\n")); + TALLOC_FREE(tmp_ctx); + return WERR_RPC_S_SERVER_UNAVAILABLE; + } + old_krb5ccname = getenv(KRB5_ENV_CCNAME); + setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1); + ADS_TALLOC_CONST_FREE(ads->auth.password); + machine_password = secrets_fetch_machine_password(lp_workgroup(), + NULL, NULL); + if (machine_password != NULL) { + ads->auth.password = talloc_strdup(ads, machine_password); + SAFE_FREE(machine_password); + if (ads->auth.password == NULL) { + result = WERR_NOT_ENOUGH_MEMORY; + goto done; + } + } + /* ads_connect() will find the DC for us */ + ads_rc = ads_connect(ads); + if (!ADS_ERR_OK(ads_rc)) { + DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc))); + result = WERR_ACCESS_DENIED; + goto done; + } + + status = make_session_info_system(tmp_ctx, &session_info); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("check_published_printers: " + "Could not create system session_info\n")); + result = WERR_ACCESS_DENIED; + goto done; + } + + for (snum = 0; snum < n_services; snum++) { + if (!lp_snum_ok(snum) || !lp_printable(snum)) { + continue; + } + + result = winreg_get_printer_internal(tmp_ctx, session_info, msg_ctx, + lp_servicename(talloc_tos(), lp_sub, snum), + &pinfo2); + if (!W_ERROR_IS_OK(result)) { + continue; + } + + if (pinfo2->attributes & PRINTER_ATTRIBUTE_PUBLISHED) { + nt_printer_publish_ads(msg_ctx, ads, pinfo2); + } + + TALLOC_FREE(pinfo2); + } + + result = WERR_OK; +done: + ads_kdestroy("MEMORY:prtpub_cache"); + unsetenv(KRB5_ENV_CCNAME); + if (old_krb5ccname) { + setenv(KRB5_ENV_CCNAME, old_krb5ccname, 0); + } + talloc_free(tmp_ctx); + return result; +} + +bool is_printer_published(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *servername, + const char *printer, + struct spoolss_PrinterInfo2 **info2) +{ + struct spoolss_PrinterInfo2 *pinfo2 = NULL; + WERROR result; + struct dcerpc_binding_handle *b; + + result = winreg_printer_binding_handle(mem_ctx, + session_info, + msg_ctx, + &b); + if (!W_ERROR_IS_OK(result)) { + return false; + } + + result = winreg_get_printer(mem_ctx, b, + printer, &pinfo2); + if (!W_ERROR_IS_OK(result)) { + return false; + } + + if (!(pinfo2->attributes & PRINTER_ATTRIBUTE_PUBLISHED)) { + TALLOC_FREE(pinfo2); + return false; + } + + if (info2) { + *info2 = talloc_move(mem_ctx, &pinfo2); + } + talloc_free(pinfo2); + return true; +} +#else +WERROR nt_printer_guid_store(struct messaging_context *msg_ctx, + const char *printer, struct GUID guid) +{ + return WERR_NOT_SUPPORTED; +} + +WERROR nt_printer_guid_retrieve(TALLOC_CTX *mem_ctx, const char *printer, + struct GUID *pguid) +{ + return WERR_NOT_SUPPORTED; +} + +WERROR nt_printer_guid_get(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *printer, struct GUID *guid) +{ + return WERR_NOT_SUPPORTED; +} + +WERROR nt_printer_publish(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + struct spoolss_PrinterInfo2 *pinfo2, + int action) +{ + return WERR_OK; +} + +WERROR check_published_printers(struct messaging_context *msg_ctx) +{ + return WERR_OK; +} + +bool is_printer_published(TALLOC_CTX *mem_ctx, + const struct auth_session_info *session_info, + struct messaging_context *msg_ctx, + const char *servername, + const char *printer, + struct spoolss_PrinterInfo2 **info2) +{ + return False; +} +#endif /* HAVE_ADS */ diff --git a/source3/printing/nt_printing_migrate.c b/source3/printing/nt_printing_migrate.c new file mode 100644 index 0000000..f56aa70 --- /dev/null +++ b/source3/printing/nt_printing_migrate.c @@ -0,0 +1,386 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * + * Copyright (c) Andreas Schneider 2010. + * Copyright (C) Bjoern Baumbach 2011 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "printing/nt_printing_migrate.h" + +#include "rpc_client/rpc_client.h" +#include "librpc/gen_ndr/ndr_ntprinting.h" +#include "librpc/gen_ndr/ndr_spoolss_c.h" +#include "librpc/gen_ndr/ndr_security.h" +#include "rpc_client/cli_winreg_spoolss.h" + +static const char *driver_file_basename(const char *file) +{ + const char *basefile; + + basefile = strrchr(file, '\\'); + if (basefile == NULL) { + basefile = file; + } else { + basefile++; + } + + return basefile; +} + +NTSTATUS printing_tdb_migrate_form(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length) +{ + struct dcerpc_binding_handle *b = winreg_pipe->binding_handle; + enum ndr_err_code ndr_err; + struct ntprinting_form r; + struct spoolss_AddFormInfo1 f1; + DATA_BLOB blob; + WERROR result; + + blob = data_blob_const(data, length); + + ZERO_STRUCT(r); + + ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r, + (ndr_pull_flags_fn_t)ndr_pull_ntprinting_form); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + DEBUG(2, ("Form pull failed: %s\n", + ndr_errstr(ndr_err))); + return NT_STATUS_NO_MEMORY; + } + + /* Don't migrate builtin forms */ + if (r.flag == SPOOLSS_FORM_BUILTIN) { + return NT_STATUS_OK; + } + + DEBUG(2, ("Migrating Form: %s\n", key_name)); + + f1.form_name = key_name; + f1.flags = r.flag; + + f1.size.width = r.width; + f1.size.height = r.length; + + f1.area.top = r.top; + f1.area.right = r.right; + f1.area.bottom = r.bottom; + f1.area.left = r.left; + + result = winreg_printer_addform1(mem_ctx, + b, + &f1); + if (W_ERROR_EQUAL(result, WERR_FILE_EXISTS)) { + /* Don't migrate form if it already exists. */ + result = WERR_OK; + } + if (!W_ERROR_IS_OK(result)) { + return werror_to_ntstatus(result); + } + + return NT_STATUS_OK; +} + +NTSTATUS printing_tdb_migrate_driver(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length, + bool do_string_conversion) +{ + struct dcerpc_binding_handle *b = winreg_pipe->binding_handle; + enum ndr_err_code ndr_err; + struct ntprinting_driver r; + struct spoolss_AddDriverInfoCtr d; + struct spoolss_AddDriverInfo3 d3; + struct spoolss_StringArray a; + DATA_BLOB blob; + WERROR result; + const char *driver_name; + uint32_t driver_version; + int i; + + blob = data_blob_const(data, length); + + ZERO_STRUCT(r); + + if (do_string_conversion) { + r.string_flags = LIBNDR_FLAG_STR_ASCII; + } + + ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r, + (ndr_pull_flags_fn_t)ndr_pull_ntprinting_driver); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + DEBUG(2, ("Driver pull failed: %s\n", + ndr_errstr(ndr_err))); + return NT_STATUS_NO_MEMORY; + } + + DEBUG(2, ("Migrating Printer Driver: %s\n", key_name)); + + ZERO_STRUCT(d3); + ZERO_STRUCT(a); + + /* remove paths from file names */ + if (r.dependent_files != NULL) { + for (i = 0 ; r.dependent_files[i] != NULL; i++) { + r.dependent_files[i] = driver_file_basename(r.dependent_files[i]); + } + } + a.string = r.dependent_files; + + r.driverpath = driver_file_basename(r.driverpath); + r.configfile = driver_file_basename(r.configfile); + r.datafile = driver_file_basename(r.datafile); + r.helpfile = driver_file_basename(r.helpfile); + + d3.architecture = r.environment; + d3.config_file = r.configfile; + d3.data_file = r.datafile; + d3.default_datatype = r.defaultdatatype; + d3.dependent_files = &a; + d3.driver_path = r.driverpath; + d3.help_file = r.helpfile; + d3.monitor_name = r.monitorname; + d3.driver_name = r.name; + d3.version = r.version; + + d.level = 3; + d.info.info3 = &d3; + + result = winreg_add_driver(mem_ctx, + b, + &d, + &driver_name, + &driver_version); + if (!W_ERROR_IS_OK(result)) { + return werror_to_ntstatus(result); + } + + return NT_STATUS_OK; +} + +NTSTATUS printing_tdb_migrate_printer(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length, + bool do_string_conversion) +{ + struct dcerpc_binding_handle *b = winreg_pipe->binding_handle; + enum ndr_err_code ndr_err; + struct ntprinting_printer r; + struct spoolss_SetPrinterInfo2 info2; + struct spoolss_DeviceMode dm; + struct spoolss_DevmodeContainer devmode_ctr; + DATA_BLOB blob; + NTSTATUS status; + WERROR result; + int j; + uint32_t info2_mask = (SPOOLSS_PRINTER_INFO_ALL) + & ~SPOOLSS_PRINTER_INFO_SECDESC; + + if (strequal(key_name, "printers")) { + return NT_STATUS_OK; + } + + blob = data_blob_const(data, length); + + ZERO_STRUCT(r); + + if (do_string_conversion) { + r.info.string_flags = LIBNDR_FLAG_STR_ASCII; + } + + ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r, + (ndr_pull_flags_fn_t) ndr_pull_ntprinting_printer); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + DEBUG(2, ("printer pull failed: %s\n", + ndr_errstr(ndr_err))); + return NT_STATUS_NO_MEMORY; + } + + DEBUG(2, ("Migrating Printer: %s\n", key_name)); + + ZERO_STRUCT(devmode_ctr); + + /* Create printer info level 2 */ + ZERO_STRUCT(info2); + + info2.attributes = r.info.attributes; + info2.averageppm = r.info.averageppm; + info2.cjobs = r.info.cjobs; + info2.comment = r.info.comment; + info2.datatype = r.info.datatype; + info2.defaultpriority = r.info.default_priority; + info2.drivername = r.info.drivername; + info2.location = r.info.location; + info2.parameters = r.info.parameters; + info2.portname = r.info.portname; + info2.printername = r.info.printername; + info2.printprocessor = r.info.printprocessor; + info2.priority = r.info.priority; + info2.sepfile = r.info.sepfile; + info2.sharename = r.info.sharename; + info2.starttime = r.info.starttime; + info2.status = r.info.status; + info2.untiltime = r.info.untiltime; + + /* Create Device Mode */ + if (r.devmode == NULL) { + info2_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE; + } else { + ZERO_STRUCT(dm); + + dm.bitsperpel = r.devmode->bitsperpel; + dm.collate = r.devmode->collate; + dm.color = r.devmode->color; + dm.copies = r.devmode->copies; + dm.defaultsource = r.devmode->defaultsource; + dm.devicename = r.devmode->devicename; + dm.displayflags = r.devmode->displayflags; + dm.displayfrequency = r.devmode->displayfrequency; + dm.dithertype = r.devmode->dithertype; + dm.driverversion = r.devmode->driverversion; + dm.duplex = r.devmode->duplex; + dm.fields = r.devmode->fields; + dm.formname = r.devmode->formname; + dm.icmintent = r.devmode->icmintent; + dm.icmmethod = r.devmode->icmmethod; + dm.logpixels = r.devmode->logpixels; + dm.mediatype = r.devmode->mediatype; + dm.orientation = r.devmode->orientation; + dm.panningheight = r.devmode->pelsheight; + dm.panningwidth = r.devmode->panningwidth; + dm.paperlength = r.devmode->paperlength; + dm.papersize = r.devmode->papersize; + dm.paperwidth = r.devmode->paperwidth; + dm.pelsheight = r.devmode->pelsheight; + dm.pelswidth = r.devmode->pelswidth; + dm.printquality = r.devmode->printquality; + dm.size = r.devmode->size; + dm.scale = r.devmode->scale; + dm.specversion = r.devmode->specversion; + dm.ttoption = r.devmode->ttoption; + dm.yresolution = r.devmode->yresolution; + + if (r.devmode->nt_dev_private != NULL) { + dm.driverextra_data.data = r.devmode->nt_dev_private->data; + dm.driverextra_data.length = r.devmode->nt_dev_private->length; + dm.__driverextra_length = r.devmode->nt_dev_private->length; + } + + devmode_ctr.devmode = &dm; + } + + result = winreg_update_printer(mem_ctx, b, + key_name, + info2_mask, + &info2, + &dm, + NULL); + if (!W_ERROR_IS_OK(result)) { + DEBUG(2, ("SetPrinter(%s) level 2 refused -- %s.\n", + key_name, win_errstr(result))); + status = werror_to_ntstatus(result); + goto done; + } + + /* migrate printerdata */ + for (j = 0; j < r.count; j++) { + char *valuename; + const char *keyname; + + if (r.printer_data[j].type == REG_NONE) { + continue; + } + + keyname = r.printer_data[j].name; + valuename = strchr(keyname, '\\'); + if (valuename == NULL) { + continue; + } else { + valuename[0] = '\0'; + valuename++; + } + + result = winreg_set_printer_dataex(mem_ctx, b, + key_name, + keyname, + valuename, + r.printer_data[j].type, + r.printer_data[j].data.data, + r.printer_data[j].data.length); + if (!W_ERROR_IS_OK(result)) { + DEBUG(2, ("SetPrinterDataEx: printer [%s], keyname [%s], " + "valuename [%s] refused -- %s.\n", + key_name, keyname, valuename, + win_errstr(result))); + status = werror_to_ntstatus(result); + break; + } + } + + status = NT_STATUS_OK; + done: + + return status; +} + +NTSTATUS printing_tdb_migrate_secdesc(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length) +{ + struct dcerpc_binding_handle *b = winreg_pipe->binding_handle; + enum ndr_err_code ndr_err; + struct sec_desc_buf secdesc_ctr; + DATA_BLOB blob; + WERROR result; + + if (strequal(key_name, "printers")) { + return NT_STATUS_OK; + } + + blob = data_blob_const(data, length); + + ZERO_STRUCT(secdesc_ctr); + + ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &secdesc_ctr, + (ndr_pull_flags_fn_t)ndr_pull_sec_desc_buf); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + DEBUG(2, ("security descriptor pull failed: %s\n", + ndr_errstr(ndr_err))); + return NT_STATUS_NO_MEMORY; + } + + DEBUG(2, ("Migrating Security Descriptor: %s\n", key_name)); + + result = winreg_set_printer_secdesc(mem_ctx, b, + key_name, + secdesc_ctr.sd); + if (!W_ERROR_IS_OK(result)) { + return werror_to_ntstatus(result); + } + + return NT_STATUS_OK; +} diff --git a/source3/printing/nt_printing_migrate.h b/source3/printing/nt_printing_migrate.h new file mode 100644 index 0000000..0c9800d --- /dev/null +++ b/source3/printing/nt_printing_migrate.h @@ -0,0 +1,47 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * + * Copyright (c) Andreas Schneider 2010. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#ifndef _NT_PRINTING_MIGRATE_H_ +#define _NT_PRINTING_MIGRATE_H_ + +NTSTATUS printing_tdb_migrate_form(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length); +NTSTATUS printing_tdb_migrate_driver(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length, + bool do_string_conversion); +NTSTATUS printing_tdb_migrate_printer(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length, + bool do_string_conversion); +NTSTATUS printing_tdb_migrate_secdesc(TALLOC_CTX *mem_ctx, + struct rpc_pipe_client *winreg_pipe, + const char *key_name, + unsigned char *data, + size_t length); + +#endif /* _NT_PRINTING_MIGRATE_H_ */ diff --git a/source3/printing/nt_printing_migrate_internal.c b/source3/printing/nt_printing_migrate_internal.c new file mode 100644 index 0000000..8bcc2d4 --- /dev/null +++ b/source3/printing/nt_printing_migrate_internal.c @@ -0,0 +1,272 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * + * Copyright (c) Andreas Schneider 2010. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "system/filesys.h" +#include "printing/nt_printing_migrate.h" +#include "printing/nt_printing_migrate_internal.h" + +#include "rpc_client/rpc_client.h" +#include "librpc/gen_ndr/ndr_spoolss_c.h" +#include "librpc/gen_ndr/ndr_winreg.h" +#include "rpc_server/rpc_ncacn_np.h" +#include "auth.h" +#include "util_tdb.h" + +#define FORMS_PREFIX "FORMS/" +#define DRIVERS_PREFIX "DRIVERS/" +#define PRINTERS_PREFIX "PRINTERS/" +#define SECDESC_PREFIX "SECDESC/" + +static int rename_file_with_suffix(TALLOC_CTX *mem_ctx, + const char *path, + const char *suffix) +{ + int rc = -1; + char *dst_path; + + dst_path = talloc_asprintf(mem_ctx, "%s%s", path, suffix); + if (dst_path == NULL) { + DEBUG(3, ("error out of memory\n")); + return rc; + } + + rc = (rename(path, dst_path) != 0); + + if (rc == 0) { + DEBUG(5, ("moved '%s' to '%s'\n", path, dst_path)); + } else if (errno == ENOENT) { + DEBUG(3, ("file '%s' does not exist - so not moved\n", path)); + rc = 0; + } else { + DEBUG(3, ("error renaming %s to %s: %s\n", path, dst_path, + strerror(errno))); + } + + TALLOC_FREE(dst_path); + return rc; +} + +static NTSTATUS migrate_internal(TALLOC_CTX *mem_ctx, + const char *tdb_path, + struct rpc_pipe_client *winreg_pipe) +{ + const char *backup_suffix = ".bak"; + TDB_DATA kbuf, newkey, dbuf; + TDB_CONTEXT *tdb; + NTSTATUS status; + int rc; + + tdb = tdb_open_log(tdb_path, 0, TDB_DEFAULT, O_RDONLY, 0600); + if (tdb == NULL && errno == ENOENT) { + /* if we have no printers database then migration is + considered successful */ + DEBUG(4, ("No printers database to migrate in %s\n", tdb_path)); + return NT_STATUS_OK; + } + if (tdb == NULL) { + DEBUG(2, ("Failed to open tdb file: %s\n", tdb_path)); + return NT_STATUS_NO_SUCH_FILE; + } + + for (kbuf = tdb_firstkey(tdb); + kbuf.dptr; + newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf = newkey) + { + dbuf = tdb_fetch(tdb, kbuf); + if (!dbuf.dptr) { + continue; + } + + if (strncmp((const char *) kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) { + status = printing_tdb_migrate_form(mem_ctx, + winreg_pipe, + (const char *) kbuf.dptr + strlen(FORMS_PREFIX), + dbuf.dptr, + dbuf.dsize); + SAFE_FREE(dbuf.dptr); + if (!NT_STATUS_IS_OK(status)) { + tdb_close(tdb); + return status; + } + continue; + } + + if (strncmp((const char *) kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) { + status = printing_tdb_migrate_driver(mem_ctx, + winreg_pipe, + (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX), + dbuf.dptr, + dbuf.dsize, + false); + SAFE_FREE(dbuf.dptr); + if (!NT_STATUS_IS_OK(status)) { + tdb_close(tdb); + return status; + } + continue; + } + + if (strncmp((const char *) kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) { + const char *printer_name = (const char *)(kbuf.dptr + + strlen(PRINTERS_PREFIX)); + status = printing_tdb_migrate_printer(mem_ctx, + winreg_pipe, + printer_name, + dbuf.dptr, + dbuf.dsize, + false); + SAFE_FREE(dbuf.dptr); + if (!NT_STATUS_IS_OK(status)) { + tdb_close(tdb); + return status; + } + continue; + } + SAFE_FREE(dbuf.dptr); + } + + for (kbuf = tdb_firstkey(tdb); + kbuf.dptr; + newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf = newkey) + { + dbuf = tdb_fetch(tdb, kbuf); + if (!dbuf.dptr) { + continue; + } + + if (strncmp((const char *) kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) { + const char *secdesc_name = (const char *)(kbuf.dptr + + strlen(SECDESC_PREFIX)); + status = printing_tdb_migrate_secdesc(mem_ctx, + winreg_pipe, + secdesc_name, + dbuf.dptr, + dbuf.dsize); + SAFE_FREE(dbuf.dptr); + if (NT_STATUS_EQUAL(status, werror_to_ntstatus(WERR_FILE_NOT_FOUND))) { + DEBUG(2, ("Skipping secdesc migration for non-existent " + "printer: %s\n", secdesc_name)); + } else if (!NT_STATUS_IS_OK(status)) { + tdb_close(tdb); + return status; + } + continue; + } + SAFE_FREE(dbuf.dptr); + } + + tdb_close(tdb); + + rc = rename_file_with_suffix(mem_ctx, tdb_path, backup_suffix); + if (rc != 0) { + DEBUG(0, ("Error moving tdb to '%s%s'\n", + tdb_path, backup_suffix)); + } + + return NT_STATUS_OK; +} + +bool nt_printing_tdb_migrate(struct messaging_context *msg_ctx) +{ + const char *drivers_path; + const char *printers_path; + const char *forms_path; + bool drivers_exists; + bool printers_exists; + bool forms_exists; + struct auth_session_info *session_info; + struct rpc_pipe_client *winreg_pipe = NULL; + TALLOC_CTX *tmp_ctx = talloc_stackframe(); + NTSTATUS status; + + /* paths talloced on new stackframe */ + drivers_path = state_path(talloc_tos(), "ntdrivers.tdb"); + printers_path = state_path(talloc_tos(), "ntprinters.tdb"); + forms_path = state_path(talloc_tos(), "ntforms.tdb"); + if ((drivers_path == NULL) || (printers_path == NULL) + || (forms_path == NULL)) { + talloc_free(tmp_ctx); + return false; + } + drivers_exists = file_exist(drivers_path); + printers_exists = file_exist(printers_path); + forms_exists = file_exist(forms_path); + + if (!drivers_exists && !printers_exists && !forms_exists) { + talloc_free(tmp_ctx); + return true; + } + + status = make_session_info_system(tmp_ctx, &session_info); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Couldn't create session_info: %s\n", + nt_errstr(status))); + talloc_free(tmp_ctx); + return false; + } + + status = rpc_pipe_open_interface(tmp_ctx, + &ndr_table_winreg, + session_info, + NULL, + NULL, + msg_ctx, + &winreg_pipe); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Couldn't open internal winreg pipe: %s\n", + nt_errstr(status))); + talloc_free(tmp_ctx); + return false; + } + + if (drivers_exists) { + status = migrate_internal(tmp_ctx, drivers_path, winreg_pipe); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Couldn't migrate drivers tdb file: %s\n", + nt_errstr(status))); + talloc_free(tmp_ctx); + return false; + } + } + + if (printers_exists) { + status = migrate_internal(tmp_ctx, printers_path, winreg_pipe); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Couldn't migrate printers tdb file: %s\n", + nt_errstr(status))); + talloc_free(tmp_ctx); + return false; + } + } + + if (forms_exists) { + status = migrate_internal(tmp_ctx, forms_path, winreg_pipe); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Couldn't migrate forms tdb file: %s\n", + nt_errstr(status))); + talloc_free(tmp_ctx); + return false; + } + } + + talloc_free(tmp_ctx); + return true; +} diff --git a/source3/printing/nt_printing_migrate_internal.h b/source3/printing/nt_printing_migrate_internal.h new file mode 100644 index 0000000..dfcf914 --- /dev/null +++ b/source3/printing/nt_printing_migrate_internal.h @@ -0,0 +1,26 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * + * Copyright (c) Andreas Schneider 2010. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#ifndef _NT_PRINTING_MIGRATE_INTERNAL_H_ +#define _NT_PRINTING_MIGRATE_INTERNAL_H_ + +bool nt_printing_tdb_migrate(struct messaging_context *msg_ctx); + +#endif /* _NT_PRINTING_MIGRATE_INTERNAL_H_ */ diff --git a/source3/printing/nt_printing_os2.c b/source3/printing/nt_printing_os2.c new file mode 100644 index 0000000..82b8248 --- /dev/null +++ b/source3/printing/nt_printing_os2.c @@ -0,0 +1,167 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (C) Andrew Tridgell 1992-2000, + * Copyright (C) Jean François Micouleau 1998-2000. + * Copyright (C) Gerald Carter 2002-2005. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "printing/nt_printing_os2.h" + +/**************************************************************************** + ***************************************************************************/ + +static char *win_driver; +static char *os2_driver; + +static const char *get_win_driver(void) +{ + if (win_driver == NULL) { + return ""; + } + return win_driver; +} + +static const char *get_os2_driver(void) +{ + if (os2_driver == NULL) { + return ""; + } + return os2_driver; +} + +static bool set_driver_mapping(const char *from, const char *to) +{ + SAFE_FREE(win_driver); + SAFE_FREE(os2_driver); + + win_driver = SMB_STRDUP(from); + os2_driver = SMB_STRDUP(to); + + if (win_driver == NULL || os2_driver == NULL) { + SAFE_FREE(win_driver); + SAFE_FREE(os2_driver); + return false; + } + return true; +} + +/** + * @internal + * + * @brief Map a Windows driver to a OS/2 driver. + * + * @param[in] mem_ctx The memory context to use. + * + * @param[in,out] pdrivername The drivername of Windows to remap. + * + * @return WERR_OK on success, a corresponding WERROR on failure. + */ +WERROR spoolss_map_to_os2_driver(TALLOC_CTX *mem_ctx, const char **pdrivername) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *mapfile = lp_os2_driver_map(talloc_tos(), lp_sub); + char **lines = NULL; + const char *drivername; + int numlines = 0; + int i; + + if (pdrivername == NULL || *pdrivername == NULL || *pdrivername[0] == '\0') { + return WERR_INVALID_PARAMETER; + } + + drivername = *pdrivername; + + if (mapfile[0] == '\0') { + return WERR_FILE_NOT_FOUND; + } + + if (strequal(drivername, get_win_driver())) { + DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n", + drivername, get_os2_driver())); + drivername = talloc_strdup(mem_ctx, get_os2_driver()); + if (drivername == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + *pdrivername = drivername; + return WERR_OK; + } + + lines = file_lines_load(mapfile, &numlines, 0, NULL); + if (numlines == 0 || lines == NULL) { + DEBUG(0,("No entries in OS/2 driver map %s\n", mapfile)); + TALLOC_FREE(lines); + return WERR_EMPTY; + } + + DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile)); + + for( i = 0; i < numlines; i++) { + char *nt_name = lines[i]; + char *os2_name = strchr(nt_name, '='); + + if (os2_name == NULL) { + continue; + } + + *os2_name++ = '\0'; + + while (isspace(*nt_name)) { + nt_name++; + } + + if (*nt_name == '\0' || strchr("#;", *nt_name)) { + continue; + } + + { + int l = strlen(nt_name); + while (l && isspace(nt_name[l - 1])) { + nt_name[l - 1] = 0; + l--; + } + } + + while (isspace(*os2_name)) { + os2_name++; + } + + { + int l = strlen(os2_name); + while (l && isspace(os2_name[l-1])) { + os2_name[l-1] = 0; + l--; + } + } + + if (strequal(nt_name, drivername)) { + DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",drivername,os2_name)); + set_driver_mapping(drivername, os2_name); + drivername = talloc_strdup(mem_ctx, os2_name); + TALLOC_FREE(lines); + if (drivername == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + *pdrivername = drivername; + return WERR_OK; + } + } + + TALLOC_FREE(lines); + return WERR_OK; +} diff --git a/source3/printing/nt_printing_os2.h b/source3/printing/nt_printing_os2.h new file mode 100644 index 0000000..0ef07de --- /dev/null +++ b/source3/printing/nt_printing_os2.h @@ -0,0 +1,22 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (C) Andrew Tridgell 1992-2000, + * Copyright (C) Jean François Micouleau 1998-2000. + * Copyright (C) Gerald Carter 2002-2005. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +WERROR spoolss_map_to_os2_driver(TALLOC_CTX *mem_ctx, const char **pdrivername); diff --git a/source3/printing/nt_printing_tdb.c b/source3/printing/nt_printing_tdb.c new file mode 100644 index 0000000..eddefe5 --- /dev/null +++ b/source3/printing/nt_printing_tdb.c @@ -0,0 +1,498 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (c) Andrew Tridgell 1992-2000, + * Copyright (c) Jean François Micouleau 1998-2000. + * Copyright (c) Gerald Carter 2002-2005. + * Copyright (c) Andreas Schneider 2010. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "system/filesys.h" +#include "printing/nt_printing_tdb.h" +#include "librpc/gen_ndr/spoolss.h" +#include "librpc/gen_ndr/ndr_security.h" +#include "libcli/security/security.h" +#include "util_tdb.h" +#include "lib/util/string_wrappers.h" + +#define FORMS_PREFIX "FORMS/" +#define DRIVERS_PREFIX "DRIVERS/" +#define PRINTERS_PREFIX "PRINTERS/" +#define SECDESC_PREFIX "SECDESC/" + +#define NTDRIVERS_DATABASE_VERSION_1 1 +#define NTDRIVERS_DATABASE_VERSION_2 2 +#define NTDRIVERS_DATABASE_VERSION_3 3 /* little endian version of v2 */ +#define NTDRIVERS_DATABASE_VERSION_4 4 /* fix generic bits in security descriptors */ +#define NTDRIVERS_DATABASE_VERSION_5 5 /* normalize keys in ntprinters.tdb */ + +static TDB_CONTEXT *tdb_forms; /* used for forms files */ +static TDB_CONTEXT *tdb_drivers; /* used for driver files */ +static TDB_CONTEXT *tdb_printers; /* used for printers files */ + +/**************************************************************************** + generate a new TDB_DATA key for storing a printer +****************************************************************************/ + +static TDB_DATA make_printer_tdbkey(TALLOC_CTX *ctx, const char *sharename ) +{ + fstring share; + char *keystr = NULL; + TDB_DATA key; + + fstrcpy(share, sharename); + (void)strlower_m(share); + + keystr = talloc_asprintf(ctx, "%s%s", PRINTERS_PREFIX, share); + key = string_term_tdb_data(keystr ? keystr : ""); + + return key; +} + +/**************************************************************************** + generate a new TDB_DATA key for storing a printer security descriptor +****************************************************************************/ + +static TDB_DATA make_printers_secdesc_tdbkey(TALLOC_CTX *ctx, + const char* sharename ) +{ + fstring share; + char *keystr = NULL; + TDB_DATA key; + + fstrcpy(share, sharename ); + (void)strlower_m(share); + + keystr = talloc_asprintf(ctx, "%s%s", SECDESC_PREFIX, share); + key = string_term_tdb_data(keystr ? keystr : ""); + + return key; +} + +/**************************************************************************** + Upgrade the tdb files to version 3 +****************************************************************************/ + +static bool upgrade_to_version_3(void) +{ + TDB_DATA kbuf, newkey, dbuf; + + DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n")); + + for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr; + newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) { + + dbuf = tdb_fetch(tdb_drivers, kbuf); + + if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) { + DEBUG(0,("upgrade_to_version_3:moving form\n")); + if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) { + SAFE_FREE(dbuf.dptr); + DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms))); + return False; + } + if (tdb_delete(tdb_drivers, kbuf) != 0) { + SAFE_FREE(dbuf.dptr); + DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers))); + return False; + } + } + + if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) { + DEBUG(0,("upgrade_to_version_3:moving printer\n")); + if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) { + SAFE_FREE(dbuf.dptr); + DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers))); + return False; + } + if (tdb_delete(tdb_drivers, kbuf) != 0) { + SAFE_FREE(dbuf.dptr); + DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers))); + return False; + } + } + + if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) { + DEBUG(0,("upgrade_to_version_3:moving secdesc\n")); + if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) { + SAFE_FREE(dbuf.dptr); + DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers))); + return False; + } + if (tdb_delete(tdb_drivers, kbuf) != 0) { + SAFE_FREE(dbuf.dptr); + DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers))); + return False; + } + } + + SAFE_FREE(dbuf.dptr); + } + + return True; +} + +/******************************************************************* + Fix an issue with security descriptors. Printer sec_desc must + use more than the generic bits that were previously used + in <= 3.0.14a. They must also have a owner and group SID assigned. + Otherwise, any printers than have been migrated to a Windows + host using printmig.exe will not be accessible. +*******************************************************************/ + +static int sec_desc_upg_fn( TDB_CONTEXT *the_tdb, TDB_DATA key, + TDB_DATA data, void *state ) +{ + NTSTATUS status; + struct sec_desc_buf *sd_orig = NULL; + struct sec_desc_buf *sd_new, *sd_store; + struct security_descriptor *sec, *new_sec; + TALLOC_CTX *ctx = state; + int result, i; + size_t size_new_sec; + + if (!data.dptr || data.dsize == 0) { + return 0; + } + + if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) != 0 ) { + return 0; + } + + /* upgrade the security descriptor */ + + status = unmarshall_sec_desc_buf(ctx, data.dptr, data.dsize, &sd_orig); + if (!NT_STATUS_IS_OK(status)) { + /* delete bad entries */ + DEBUG(0,("sec_desc_upg_fn: Failed to parse original sec_desc for %si. Deleting....\n", + (const char *)key.dptr )); + tdb_delete( tdb_printers, key ); + return 0; + } + + if (!sd_orig) { + return 0; + } + sec = sd_orig->sd; + + /* is this even valid? */ + + if ( !sec->dacl ) { + return 0; + } + + /* update access masks */ + + for ( i=0; idacl->num_aces; i++ ) { + switch ( sec->dacl->aces[i].access_mask ) { + case (GENERIC_READ_ACCESS | GENERIC_WRITE_ACCESS | GENERIC_EXECUTE_ACCESS): + sec->dacl->aces[i].access_mask = PRINTER_ACE_PRINT; + break; + + case GENERIC_ALL_ACCESS: + sec->dacl->aces[i].access_mask = PRINTER_ACE_FULL_CONTROL; + break; + + case READ_CONTROL_ACCESS: + sec->dacl->aces[i].access_mask = PRINTER_ACE_MANAGE_DOCUMENTS; + + break; + default: /* no change */ + break; + } + } + + /* create a new struct security_descriptor with the appropriate owner and group SIDs */ + + new_sec = make_sec_desc( ctx, SD_REVISION, SEC_DESC_SELF_RELATIVE, + &global_sid_Builtin_Administrators, + &global_sid_Builtin_Administrators, + NULL, NULL, &size_new_sec ); + if (!new_sec) { + return 0; + } + sd_new = make_sec_desc_buf( ctx, size_new_sec, new_sec ); + if (!sd_new) { + return 0; + } + + if ( !(sd_store = sec_desc_merge_buf( ctx, sd_new, sd_orig )) ) { + DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key.dptr )); + return 0; + } + + /* store it back */ + + status = marshall_sec_desc_buf(ctx, sd_store, &data.dptr, &data.dsize); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key.dptr )); + return 0; + } + + result = tdb_store( tdb_printers, key, data, TDB_REPLACE ); + + /* 0 to continue and non-zero to stop traversal */ + + return (result != 0); +} + +/******************************************************************* + Upgrade the tdb files to version 4 +*******************************************************************/ + +static bool upgrade_to_version_4(void) +{ + TALLOC_CTX *ctx; + int result; + + DEBUG(0,("upgrade_to_version_4: upgrading printer security descriptors\n")); + + if ( !(ctx = talloc_init( "upgrade_to_version_4" )) ) + return False; + + result = tdb_traverse( tdb_printers, sec_desc_upg_fn, ctx ); + + talloc_destroy( ctx ); + + return ( result >= 0 ); +} + +/******************************************************************* + Fix an issue with security descriptors. Printer sec_desc must + use more than the generic bits that were previously used + in <= 3.0.14a. They must also have a owner and group SID assigned. + Otherwise, any printers than have been migrated to a Windows + host using printmig.exe will not be accessible. +*******************************************************************/ + +static int normalize_printers_fn( TDB_CONTEXT *the_tdb, TDB_DATA key, + TDB_DATA data, void *state ) +{ + TALLOC_CTX *ctx = talloc_tos(); + TDB_DATA new_key; + + if (!data.dptr || data.dsize == 0) + return 0; + + /* upgrade printer records and security descriptors */ + + if ( strncmp((const char *) key.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX) ) == 0 ) { + new_key = make_printer_tdbkey(ctx, (const char *)key.dptr+strlen(PRINTERS_PREFIX) ); + } + else if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) == 0 ) { + new_key = make_printers_secdesc_tdbkey(ctx, (const char *)key.dptr+strlen(SECDESC_PREFIX) ); + } + else { + /* ignore this record */ + return 0; + } + + /* delete the original record and store under the normalized key */ + + if ( tdb_delete( the_tdb, key ) != 0 ) { + DEBUG(0,("normalize_printers_fn: tdb_delete for [%s] failed!\n", + key.dptr)); + return 1; + } + + if ( tdb_store( the_tdb, new_key, data, TDB_REPLACE) != 0 ) { + DEBUG(0,("normalize_printers_fn: failed to store new record for [%s]!\n", + key.dptr)); + return 1; + } + + return 0; +} + +/******************************************************************* + Upgrade the tdb files to version 5 +*******************************************************************/ + +static bool upgrade_to_version_5(void) +{ + TALLOC_CTX *ctx; + int result; + + DEBUG(0,("upgrade_to_version_5: normalizing printer keys\n")); + + if ( !(ctx = talloc_init( "upgrade_to_version_5" )) ) + return False; + + result = tdb_traverse( tdb_printers, normalize_printers_fn, NULL ); + + talloc_destroy( ctx ); + + return ( result >= 0 ); +} + +bool nt_printing_tdb_upgrade(void) +{ + char *drivers_path; + char *printers_path; + char *forms_path; + bool drivers_exists; + bool printers_exists; + bool forms_exists; + const char *vstring = "INFO/version"; + int32_t vers_id; + bool ret; + + drivers_path = state_path(talloc_tos(), "ntdrivers.tdb"); + if (drivers_path == NULL) { + ret = false; + goto err_out; + } + printers_path = state_path(talloc_tos(), "ntprinters.tdb"); + if (printers_path == NULL) { + ret = false; + goto err_drvdb_free; + } + forms_path = state_path(talloc_tos(), "ntforms.tdb"); + if (forms_path == NULL) { + ret = false; + goto err_prdb_free; + } + + drivers_exists = file_exist(drivers_path); + printers_exists = file_exist(printers_path); + forms_exists = file_exist(forms_path); + + if (!drivers_exists && !printers_exists && !forms_exists) { + ret = true; + goto err_formsdb_free; + } + + tdb_drivers = tdb_open_log(drivers_path, + 0, + TDB_DEFAULT, + O_RDWR|O_CREAT, + 0600); + if (tdb_drivers == NULL) { + DEBUG(0,("nt_printing_init: Failed to open nt drivers " + "database %s (%s)\n", + drivers_path, strerror(errno))); + ret = false; + goto err_formsdb_free; + } + + tdb_printers = tdb_open_log(printers_path, + 0, + TDB_DEFAULT, + O_RDWR|O_CREAT, + 0600); + if (tdb_printers == NULL) { + DEBUG(0,("nt_printing_init: Failed to open nt printers " + "database %s (%s)\n", + printers_path, strerror(errno))); + ret = false; + goto err_drvdb_close; + } + + tdb_forms = tdb_open_log(forms_path, + 0, + TDB_DEFAULT, + O_RDWR|O_CREAT, + 0600); + if (tdb_forms == NULL) { + DEBUG(0,("nt_printing_init: Failed to open nt forms " + "database %s (%s)\n", + forms_path, strerror(errno))); + ret = false; + goto err_prdb_close; + } + + /* Samba upgrade */ + vers_id = tdb_fetch_int32(tdb_drivers, vstring); + if (vers_id == -1) { + DEBUG(10, ("Fresh database\n")); + tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5); + vers_id = NTDRIVERS_DATABASE_VERSION_5; + } + + if (vers_id != NTDRIVERS_DATABASE_VERSION_5) { + if ((vers_id == NTDRIVERS_DATABASE_VERSION_1) || + (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_1)) { + if (!upgrade_to_version_3()) { + ret = false; + goto err_formsdb_close; + } + + tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3); + vers_id = NTDRIVERS_DATABASE_VERSION_3; + } + + if ((vers_id == NTDRIVERS_DATABASE_VERSION_2) || + (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_2)) { + /* + * Written on a bigendian machine with old fetch_int + * code. Save as le. The only upgrade between V2 and V3 + * is to save the version in little-endian. + */ + tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3); + vers_id = NTDRIVERS_DATABASE_VERSION_3; + } + + if (vers_id == NTDRIVERS_DATABASE_VERSION_3) { + if (!upgrade_to_version_4()) { + ret = false; + goto err_formsdb_close; + } + tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_4); + vers_id = NTDRIVERS_DATABASE_VERSION_4; + } + + if (vers_id == NTDRIVERS_DATABASE_VERSION_4 ) { + if (!upgrade_to_version_5()) { + ret = false; + goto err_formsdb_close; + } + tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5); + vers_id = NTDRIVERS_DATABASE_VERSION_5; + } + + if (vers_id != NTDRIVERS_DATABASE_VERSION_5) { + DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id)); + ret = false; + goto err_formsdb_close; + } + } + ret = true; + +err_formsdb_close: + if (tdb_forms) { + tdb_close(tdb_forms); + tdb_forms = NULL; + } +err_prdb_close: + if (tdb_printers) { + tdb_close(tdb_printers); + tdb_printers = NULL; + } +err_drvdb_close: + if (tdb_drivers) { + tdb_close(tdb_drivers); + tdb_drivers = NULL; + } +err_formsdb_free: + talloc_free(forms_path); +err_prdb_free: + talloc_free(printers_path); +err_drvdb_free: + talloc_free(drivers_path); +err_out: + return ret; +} diff --git a/source3/printing/nt_printing_tdb.h b/source3/printing/nt_printing_tdb.h new file mode 100644 index 0000000..81e1813 --- /dev/null +++ b/source3/printing/nt_printing_tdb.h @@ -0,0 +1,28 @@ +/* + * Unix SMB/CIFS implementation. + * RPC Pipe client / server routines + * Copyright (c) Andrew Tridgell 1992-2000, + * Copyright (c) Jean François Micouleau 1998-2000. + * Copyright (c) Gerald Carter 2002-2005. + * Copyright (c) Andreas Schneider 2010. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#ifndef _NT_PRINTING_TDB_H_ +#define _NT_PRINTING_TDB_H_ + +bool nt_printing_tdb_upgrade(void); + +#endif /* _NT_PRINTING_TDB_H_ */ diff --git a/source3/printing/pcap.c b/source3/printing/pcap.c new file mode 100644 index 0000000..ec68d29 --- /dev/null +++ b/source3/printing/pcap.c @@ -0,0 +1,213 @@ +/* + Unix SMB/CIFS implementation. + printcap parsing + Copyright (C) Karl Auer 1993-1998 + + Re-working by Martin Kiff, 1994 + + Re-written again by Andrew Tridgell + + Modified for SVID support by Norm Jacobs, 1997 + + Modified for CUPS support by Michael Sweet, 1999 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + * Modified to call SVID/XPG4 support if printcap name is set to "lpstat" + * in smb.conf under Solaris. + * + * Modified to call CUPS support if printcap name is set to "cups" + * in smb.conf. + * + * Modified to call iPrint support if printcap name is set to "iprint" + * in smb.conf. + */ + +#include "includes.h" +#include "printing/pcap.h" +#include "printer_list.h" + +struct pcap_cache { + char *name; + char *comment; + char *location; + struct pcap_cache *next; +}; + +bool pcap_cache_add_specific(struct pcap_cache **ppcache, const char *name, const char *comment, const char *location) +{ + struct pcap_cache *p; + + if (name == NULL || ((p = SMB_MALLOC_P(struct pcap_cache)) == NULL)) + return false; + + p->name = SMB_STRDUP(name); + p->comment = (comment && *comment) ? SMB_STRDUP(comment) : NULL; + p->location = (location && *location) ? SMB_STRDUP(location) : NULL; + + DEBUG(11,("pcap_cache_add_specific: Adding name %s info %s, location: %s\n", + p->name, p->comment ? p->comment : "", + p->location ? p->location : "")); + + p->next = *ppcache; + *ppcache = p; + + return true; +} + +void pcap_cache_destroy_specific(struct pcap_cache **pp_cache) +{ + struct pcap_cache *p, *next; + + for (p = *pp_cache; p != NULL; p = next) { + next = p->next; + + SAFE_FREE(p->name); + SAFE_FREE(p->comment); + SAFE_FREE(p->location); + SAFE_FREE(p); + } + *pp_cache = NULL; +} + +bool pcap_cache_replace(const struct pcap_cache *pcache) +{ + const struct pcap_cache *p; + NTSTATUS status; + time_t t = time_mono(NULL); + + status = printer_list_mark_reload(); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Failed to mark printer list for reload!\n")); + return false; + } + + for (p = pcache; p; p = p->next) { + status = printer_list_set_printer(talloc_tos(), p->name, + p->comment, p->location, t); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + } + + status = printer_list_clean_old(); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Failed to cleanup printer list!\n")); + return false; + } + + return true; +} + +void pcap_cache_reload(struct tevent_context *ev, + struct messaging_context *msg_ctx, + void (*post_cache_fill_fn)(struct tevent_context *, + struct messaging_context *)) +{ + const char *pcap_name = lp_printcapname(); + bool pcap_reloaded = False; + bool post_cache_fill_fn_handled = false; + struct pcap_cache *pcache = NULL; + + DEBUG(3, ("reloading printcap cache\n")); + + if (!lp_load_printers()) { + DBG_NOTICE("skipping reload - load printers disabled\n"); + return; + } + + /* only go looking if a printcap name is supplied */ + if (pcap_name == NULL || *pcap_name == 0) { + DEBUG(0, ("No printcap file name configured!\n")); + return; + } + +#ifdef HAVE_CUPS + if (strequal(pcap_name, "cups")) { + pcap_reloaded = cups_cache_reload(ev, msg_ctx, + post_cache_fill_fn); + /* + * cups_cache_reload() is async and calls post_cache_fill_fn() + * on successful completion + */ + post_cache_fill_fn_handled = true; + goto done; + } +#endif + +#ifdef HAVE_IPRINT + if (strequal(pcap_name, "iprint")) { + pcap_reloaded = iprint_cache_reload(&pcache); + goto done; + } +#endif + +#if defined(SYSV) || defined(HPUX) + if (strequal(pcap_name, "lpstat")) { + pcap_reloaded = sysv_cache_reload(&pcache); + goto done; + } +#endif + +#ifdef AIX + if (strstr_m(pcap_name, "/qconfig") != NULL) { + pcap_reloaded = aix_cache_reload(&pcache); + goto done; + } +#endif + + pcap_reloaded = std_pcap_cache_reload(pcap_name, &pcache); + +/* Fix silly compiler warning about done not being used if none of the above + * ifdefs are used */ +#if defined(HAVE_CUPS) || defined(HAVE_IPRINT) || defined(SYSV) || defined(HPUX) || defined(AIX) +done: +#endif + DEBUG(3, ("reload status: %s\n", (pcap_reloaded) ? "ok" : "error")); + + if ((pcap_reloaded) && (post_cache_fill_fn_handled == false)) { + /* cleanup old entries only if the operation was successful, + * otherwise keep around the old entries until we can + * successfully reload */ + + if (!pcap_cache_replace(pcache)) { + DEBUG(0, ("Failed to replace printer list!\n")); + } + + if (post_cache_fill_fn != NULL) { + post_cache_fill_fn(ev, msg_ctx); + } + } + pcap_cache_destroy_specific(&pcache); + + return; +} + +/*************************************************************************** +run a function on each printer name in the printcap file. +***************************************************************************/ + +void pcap_printer_fn_specific(const struct pcap_cache *pc, + void (*fn)(const char *, const char *, const char *, void *), + void *pdata) +{ + const struct pcap_cache *p; + + for (p = pc; p != NULL; p = p->next) + fn(p->name, p->comment, p->location, pdata); + + return; +} diff --git a/source3/printing/pcap.h b/source3/printing/pcap.h new file mode 100644 index 0000000..99a0a91 --- /dev/null +++ b/source3/printing/pcap.h @@ -0,0 +1,69 @@ +/* + Unix SMB/CIFS implementation. + printcap headers + + Copyright (C) Karl Auer 1993-1998 + + Re-working by Martin Kiff, 1994 + + Re-written again by Andrew Tridgell + + Modified for SVID support by Norm Jacobs, 1997 + + Modified for CUPS support by Michael Sweet, 1999 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef _PRINTING_PCAP_H_ +#define _PRINTING_PCAP_H_ + +struct pcap_cache; + +/* The following definitions come from printing/pcap.c */ + +bool pcap_cache_add_specific(struct pcap_cache **ppcache, const char *name, const char *comment, const char *location); +void pcap_cache_destroy_specific(struct pcap_cache **ppcache); +bool pcap_cache_replace(const struct pcap_cache *cache); +void pcap_printer_fn_specific(const struct pcap_cache *, void (*fn)(const char *, const char *, const char *, void *), void *); + +void pcap_cache_reload(struct tevent_context *ev, + struct messaging_context *msg_ctx, + void (*post_cache_fill_fn)(struct tevent_context *, + struct messaging_context *)); +bool pcap_printername_ok(const char *printername); + +/* The following definitions come from printing/print_aix.c */ + +bool aix_cache_reload(struct pcap_cache **_pcache); + +/* The following definitions come from printing/print_cups.c */ + +bool cups_cache_reload(struct tevent_context *ev, + struct messaging_context *msg_ctx, + void (*post_cache_fill_fn)(struct tevent_context *, + struct messaging_context *)); + +/* The following definitions come from printing/print_iprint.c */ + +bool iprint_cache_reload(struct pcap_cache **_pcache); + +/* The following definitions come from printing/print_svid.c */ + +bool sysv_cache_reload(struct pcap_cache **_pcache); + +/* The following definitions come from printing/print_standard.c */ +bool std_pcap_cache_reload(const char *pcap_name, struct pcap_cache **_pcache); + +#endif /* _PRINTING_PCAP_H_ */ diff --git a/source3/printing/print_aix.c b/source3/printing/print_aix.c new file mode 100644 index 0000000..d3836a4 --- /dev/null +++ b/source3/printing/print_aix.c @@ -0,0 +1,140 @@ +/* + AIX-specific printcap loading + Copyright (C) Jean-Pierre.Boulard@univ-rennes1.fr 1996 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + * This module implements AIX-specific printcap loading. Most of the code + * here was originally provided by Jean-Pierre.Boulard@univ-rennes1.fr in + * the Samba 1.9.14 release, and was formerly contained in pcap.c. It has + * been moved here and condensed as part of a larger effort to clean up and + * simplify the printcap code. -- Rob Foehl, 2004/12/06 + */ + +#include "includes.h" +#include "system/filesys.h" +#include "printing/pcap.h" + +#ifdef AIX +bool aix_cache_reload(struct pcap_cache **_pcache) +{ + int iEtat; + FILE *pfile; + char *line = NULL, *p; + char *name = NULL; + struct pcap_cache *pcache = NULL; + TALLOC_CTX *ctx = talloc_init("aix_cache_reload"); + + if (!ctx) { + return false; + } + + DEBUG(5, ("reloading aix printcap cache\n")); + + if ((pfile = fopen(lp_printcapname(), "r")) == NULL) { + DEBUG(0,( "Unable to open qconfig file %s for read!\n", lp_printcapname())); + TALLOC_FREE(ctx); + return false; + } + + iEtat = 0; + /* scan qconfig file for searching : */ + while (line = fgets_slash(ctx, NULL, 1024, pfile)) { + bool ok; + + if (*line == '*' || *line == 0) { + TALLOC_FREE(line); + continue; + } + + switch (iEtat) { + case 0: /* locate an entry */ + if (*line == '\t' || *line == ' ') { + TALLOC_FREE(line); + continue; + } + + if ((p = strchr_m(line, ':'))) { + char *saveptr; + *p = '\0'; + p = strtok_r(line, ":", &saveptr); + if (strcmp(p, "bsh") != 0) { + name = talloc_strdup(ctx, p); + if (!name) { + pcap_cache_destroy_specific(&pcache); + TALLOC_FREE(line); + fclose(pfile); + TALLOC_FREE(ctx); + return false; + } + iEtat = 1; + continue; + } + } + break; + + case 1: /* scanning device stanza */ + if (*line == '*' || *line == 0) + continue; + + if (*line != '\t' && *line != ' ') { + /* name is found without stanza device */ + /* probably a good printer ??? */ + iEtat = 0; + ok = pcap_cache_add_specific(&pcache, + name, NULL, NULL); + if (!ok) { + pcap_cache_destroy_specific(&pcache); + TALLOC_FREE(line); + fclose(pfile); + TALLOC_FREE(ctx); + return false; + } + continue; + } + + if (strstr_m(line, "backend")) { + /* it's a device, not a virtual printer */ + iEtat = 0; + } else if (strstr_m(line, "device")) { + /* it's a good virtual printer */ + iEtat = 0; + ok = pcap_cache_add_specific(&pcache, + name, NULL, NULL); + if (!ok) { + pcap_cache_destroy_specific(&pcache); + SAFE_FREE(line); + fclose(pfile); + TALLOC_FREE(ctx); + return false; + } + continue; + } + break; + } + } + + *_pcache = pcache; + fclose(pfile); + TALLOC_FREE(ctx); + return true; +} + +#else +/* this keeps fussy compilers happy */ + void print_aix_dummy(void); + void print_aix_dummy(void) {} +#endif /* AIX */ diff --git a/source3/printing/print_cups.c b/source3/printing/print_cups.c new file mode 100644 index 0000000..d8ba9cc --- /dev/null +++ b/source3/printing/print_cups.c @@ -0,0 +1,1749 @@ +/* + * Support code for the Common UNIX Printing System ("CUPS") + * + * Copyright 1999-2003 by Michael R Sweet. + * Copyright 2008 Jeremy Allison. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * JRA. Converted to utf8 pull/push. + */ + +#include "includes.h" +#include "printing.h" +#include "printing/pcap.h" +#include "librpc/gen_ndr/ndr_printcap.h" +#include "lib/util/sys_rw.h" +#include "lib/util/string_wrappers.h" + +#ifdef HAVE_CUPS +#include +#include +#include + +/* CUPS prior to version 1.7 doesn't have HTTP_URI_STATUS_OK */ +#if (CUPS_VERSION_MAJOR == 1) && (CUPS_VERSION_MINOR < 7) +#define HTTP_URI_STATUS_OK HTTP_URI_OK +#endif + +#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5) +#define HAVE_CUPS_1_6 1 +#endif + +#ifndef HAVE_CUPS_1_6 +#define ippGetGroupTag(attr) attr->group_tag +#define ippGetName(attr) attr->name +#define ippGetValueTag(attr) attr->value_tag +#define ippGetStatusCode(ipp) ipp->request.status.status_code +#define ippGetInteger(attr, element) attr->values[element].integer +#define ippGetString(attr, element, language) attr->values[element].string.text + +static ipp_attribute_t * +ippFirstAttribute(ipp_t *ipp) +{ + if (!ipp) + return (NULL); + return (ipp->current = ipp->attrs); +} + +static ipp_attribute_t * +ippNextAttribute(ipp_t *ipp) +{ + if (!ipp || !ipp->current) + return (NULL); + return (ipp->current = ipp->current->next); +} + +static int ippSetOperation(ipp_t *ipp, ipp_op_t op) +{ + ipp->request.op.operation_id = op; + return (1); +} + +static int ippSetRequestId(ipp_t *ipp, int request_id) +{ + ipp->request.any.request_id = request_id; + return (1); +} +#endif + +static SIG_ATOMIC_T gotalarm; + +/*************************************************************** + Signal function to tell us we timed out. +****************************************************************/ + +static void gotalarm_sig(int signum) +{ + gotalarm = 1; +} + +extern userdom_struct current_user_info; + +/* + * 'cups_passwd_cb()' - The CUPS password callback... + */ + +static const char * /* O - Password or NULL */ +cups_passwd_cb(const char *prompt) /* I - Prompt */ +{ + /* + * Always return NULL to indicate that no password is available... + */ + + return (NULL); +} + +static http_t *cups_connect(TALLOC_CTX *frame) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + http_t *http = NULL; + char *server = NULL, *p = NULL; + int port; + int timeout = lp_cups_connection_timeout(); + size_t size; + + if (lp_cups_server(talloc_tos(), lp_sub) != NULL && strlen(lp_cups_server(talloc_tos(), lp_sub)) > 0) { + if (!push_utf8_talloc(frame, &server, lp_cups_server(talloc_tos(), lp_sub), &size)) { + return NULL; + } + } else { + server = talloc_strdup(frame,cupsServer()); + } + if (!server) { + return NULL; + } + + p = strchr(server, ':'); + if (p) { + port = atoi(p+1); + *p = '\0'; + } else { + port = ippPort(); + } + + DEBUG(10, ("connecting to cups server %s:%d\n", + server, port)); + + gotalarm = 0; + + if (timeout) { + CatchSignal(SIGALRM, gotalarm_sig); + alarm(timeout); + } + +#if defined(HAVE_HTTPCONNECT2) + http = httpConnect2(server, + port, + NULL, + AF_UNSPEC, + lp_cups_encrypt() ? + HTTP_ENCRYPTION_ALWAYS : + HTTP_ENCRYPTION_IF_REQUESTED, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#elif defined(HAVE_HTTPCONNECTENCRYPT) + http = httpConnectEncrypt(server, port, lp_cups_encrypt()); +#else + http = httpConnect(server, port); +#endif + + + CatchSignal(SIGALRM, SIG_IGN); + alarm(0); + + if (http == NULL) { + DEBUG(3,("Unable to connect to CUPS server %s:%d - %s\n", + server, port, strerror(errno))); + } + + return http; +} + +static bool send_pcap_blob(DATA_BLOB *pcap_blob, int fd) +{ + size_t ret; + + ret = sys_write(fd, &pcap_blob->length, sizeof(pcap_blob->length)); + if (ret != sizeof(pcap_blob->length)) { + return false; + } + + ret = sys_write(fd, pcap_blob->data, pcap_blob->length); + if (ret != pcap_blob->length) { + return false; + } + + DEBUG(10, ("successfully sent blob of len %d\n", (int)ret)); + return true; +} + +static bool recv_pcap_blob(TALLOC_CTX *mem_ctx, int fd, DATA_BLOB *pcap_blob) +{ + size_t blob_len; + size_t ret; + + ret = sys_read(fd, &blob_len, sizeof(blob_len)); + if (ret != sizeof(blob_len)) { + return false; + } + + *pcap_blob = data_blob_talloc_named(mem_ctx, NULL, blob_len, + "cups pcap"); + if (pcap_blob->length != blob_len) { + return false; + } + ret = sys_read(fd, pcap_blob->data, blob_len); + if (ret != blob_len) { + talloc_free(pcap_blob->data); + return false; + } + + DEBUG(10, ("successfully recvd blob of len %d\n", (int)ret)); + return true; +} + +static bool process_cups_printers_response(TALLOC_CTX *mem_ctx, + ipp_t *response, + struct pcap_data *pcap_data) +{ + ipp_attribute_t *attr; + char *name; + char *info; + char *location = NULL; + struct pcap_printer *printer; + bool ret_ok = false; + + for (attr = ippFirstAttribute(response); attr != NULL;) { + /* + * Skip leading attributes until we hit a printer... + */ + + while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER) + attr = ippNextAttribute(response); + + if (attr == NULL) + break; + + /* + * Pull the needed attributes from this printer... + */ + + name = NULL; + info = NULL; + + while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER) { + size_t size; + if (strcmp(ippGetName(attr), "printer-name") == 0 && + ippGetValueTag(attr) == IPP_TAG_NAME) { + if (!pull_utf8_talloc(mem_ctx, + &name, + ippGetString(attr, 0, NULL), + &size)) { + goto err_out; + } + } + + if (strcmp(ippGetName(attr), "printer-info") == 0 && + ippGetValueTag(attr) == IPP_TAG_TEXT) { + if (!pull_utf8_talloc(mem_ctx, + &info, + ippGetString(attr, 0, NULL), + &size)) { + goto err_out; + } + } + + if (strcmp(ippGetName(attr), "printer-location") == 0 && + ippGetValueTag(attr) == IPP_TAG_TEXT) { + if (!pull_utf8_talloc(mem_ctx, + &location, + ippGetString(attr, 0, NULL), + &size)) { + goto err_out; + } + } + + attr = ippNextAttribute(response); + } + + /* + * See if we have everything needed... + */ + + if (name == NULL) + break; + + if (pcap_data->count == 0) { + printer = talloc_array(mem_ctx, struct pcap_printer, 1); + } else { + printer = talloc_realloc(mem_ctx, pcap_data->printers, + struct pcap_printer, + pcap_data->count + 1); + } + if (printer == NULL) { + goto err_out; + } + pcap_data->printers = printer; + pcap_data->printers[pcap_data->count].name = name; + pcap_data->printers[pcap_data->count].info = info; + pcap_data->printers[pcap_data->count].location = location; + pcap_data->count++; + } + + ret_ok = true; +err_out: + return ret_ok; +} + +/* + * request printer list from cups, send result back to up parent via fd. + * returns true if the (possibly failed) result was successfully sent to parent. + */ +static bool cups_cache_reload_async(int fd) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct pcap_data pcap_data; + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + static const char *requested[] =/* Requested attributes */ + { + "printer-name", + "printer-info", + "printer-location" + }; + bool ret = False; + enum ndr_err_code ndr_ret; + DATA_BLOB pcap_blob; + + ZERO_STRUCT(pcap_data); + pcap_data.status = NT_STATUS_UNSUCCESSFUL; + + DEBUG(5, ("reloading cups printcap cache\n")); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build a CUPS_GET_PRINTERS request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * requested-attributes + */ + + request = ippNew(); + + ippSetOperation(request, CUPS_GET_PRINTERS); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME, + "requested-attributes", + (sizeof(requested) / sizeof(requested[0])), + NULL, requested); + + if ((response = cupsDoRequest(http, request, "/")) == NULL) { + DEBUG(0,("Unable to get printer list - %s\n", + ippErrorString(cupsLastError()))); + goto out; + } + + ret = process_cups_printers_response(frame, response, &pcap_data); + if (!ret) { + DEBUG(0,("failed to process cups response\n")); + goto out; + } + + ippDelete(response); + response = NULL; + + /* + * Build a CUPS_GET_CLASSES request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * requested-attributes + */ + + request = ippNew(); + + ippSetOperation(request, CUPS_GET_CLASSES); + ippSetRequestId(request, 1); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME, + "requested-attributes", + (sizeof(requested) / sizeof(requested[0])), + NULL, requested); + + if ((response = cupsDoRequest(http, request, "/")) == NULL) { + DEBUG(0,("Unable to get printer list - %s\n", + ippErrorString(cupsLastError()))); + goto out; + } + + ret = process_cups_printers_response(frame, response, &pcap_data); + if (!ret) { + DEBUG(0,("failed to process cups response\n")); + goto out; + } + + pcap_data.status = NT_STATUS_OK; + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + ret = false; + ndr_ret = ndr_push_struct_blob(&pcap_blob, frame, &pcap_data, + (ndr_push_flags_fn_t)ndr_push_pcap_data); + if (ndr_ret == NDR_ERR_SUCCESS) { + ret = send_pcap_blob(&pcap_blob, fd); + } + + TALLOC_FREE(frame); + return ret; +} + +static struct tevent_fd *cache_fd_event; + +static bool cups_pcap_load_async(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int *pfd) +{ + int fds[2]; + pid_t pid; + NTSTATUS status; + + *pfd = -1; + + if (cache_fd_event) { + DEBUG(3,("cups_pcap_load_async: already waiting for " + "a refresh event\n" )); + return false; + } + + DEBUG(5,("cups_pcap_load_async: asynchronously loading cups printers\n")); + + if (pipe(fds) == -1) { + return false; + } + + pid = fork(); + if (pid == (pid_t)-1) { + DEBUG(10,("cups_pcap_load_async: fork failed %s\n", + strerror(errno) )); + close(fds[0]); + close(fds[1]); + return false; + } + + if (pid) { + DEBUG(10,("cups_pcap_load_async: child pid = %u\n", + (unsigned int)pid )); + /* Parent. */ + close(fds[1]); + *pfd = fds[0]; + return true; + } + + /* Child. */ + + close_all_print_db(); + + status = reinit_after_fork(msg_ctx, ev, true); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0,("cups_pcap_load_async: reinit_after_fork() failed\n")); + smb_panic("cups_pcap_load_async: reinit_after_fork() failed"); + } + + close(fds[0]); + cups_cache_reload_async(fds[1]); + close(fds[1]); + TALLOC_FREE(msg_ctx); + _exit(0); +} + +struct cups_async_cb_args { + int pipe_fd; + struct tevent_context *event_ctx; + struct messaging_context *msg_ctx; + void (*post_cache_fill_fn)(struct tevent_context *, + struct messaging_context *); +}; + +static void cups_async_callback(struct tevent_context *event_ctx, + struct tevent_fd *event, + uint16_t flags, + void *p) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct cups_async_cb_args *cb_args = (struct cups_async_cb_args *)p; + struct pcap_cache *tmp_pcap_cache = NULL; + bool ret_ok; + struct pcap_data pcap_data; + DATA_BLOB pcap_blob; + enum ndr_err_code ndr_ret; + uint32_t i; + + DEBUG(5,("cups_async_callback: callback received for printer data. " + "fd = %d\n", cb_args->pipe_fd)); + + ret_ok = recv_pcap_blob(frame, cb_args->pipe_fd, &pcap_blob); + if (!ret_ok) { + DEBUG(0,("failed to recv pcap blob\n")); + goto err_out; + } + + ndr_ret = ndr_pull_struct_blob(&pcap_blob, frame, &pcap_data, + (ndr_pull_flags_fn_t)ndr_pull_pcap_data); + if (ndr_ret != NDR_ERR_SUCCESS) { + goto err_out; + } + + if (!NT_STATUS_IS_OK(pcap_data.status)) { + DEBUG(3,("failed to retrieve printer list: %s\n", + nt_errstr(pcap_data.status))); + goto err_out; + } + + for (i = 0; i < pcap_data.count; i++) { + ret_ok = pcap_cache_add_specific(&tmp_pcap_cache, + pcap_data.printers[i].name, + pcap_data.printers[i].info, + pcap_data.printers[i].location); + if (!ret_ok) { + DEBUG(0, ("failed to add to tmp pcap cache\n")); + goto err_out; + } + } + + /* replace the system-wide pcap cache with a (possibly empty) new one */ + ret_ok = pcap_cache_replace(tmp_pcap_cache); + if (!ret_ok) { + DEBUG(0, ("failed to replace pcap cache\n")); + } else if (cb_args->post_cache_fill_fn != NULL) { + /* Caller requested post cache fill callback */ + cb_args->post_cache_fill_fn(cb_args->event_ctx, + cb_args->msg_ctx); + } +err_out: + pcap_cache_destroy_specific(&tmp_pcap_cache); + TALLOC_FREE(frame); + TALLOC_FREE(cache_fd_event); + close(cb_args->pipe_fd); + TALLOC_FREE(cb_args); +} + +bool cups_cache_reload(struct tevent_context *ev, + struct messaging_context *msg_ctx, + void (*post_cache_fill_fn)(struct tevent_context *, + struct messaging_context *)) +{ + struct cups_async_cb_args *cb_args; + int *p_pipe_fd; + + cb_args = talloc(NULL, struct cups_async_cb_args); + if (cb_args == NULL) { + return false; + } + + cb_args->post_cache_fill_fn = post_cache_fill_fn; + cb_args->event_ctx = ev; + cb_args->msg_ctx = msg_ctx; + p_pipe_fd = &cb_args->pipe_fd; + *p_pipe_fd = -1; + + /* Set up an async refresh. */ + if (!cups_pcap_load_async(ev, msg_ctx, p_pipe_fd)) { + talloc_free(cb_args); + return false; + } + + DEBUG(10,("cups_cache_reload: async read on fd %d\n", + *p_pipe_fd )); + + /* Trigger an event when the pipe can be read. */ + cache_fd_event = tevent_add_fd(ev, + NULL, *p_pipe_fd, + TEVENT_FD_READ, + cups_async_callback, + (void *)cb_args); + if (!cache_fd_event) { + close(*p_pipe_fd); + TALLOC_FREE(cb_args); + return false; + } + + return true; +} + +/* + * 'cups_job_delete()' - Delete a job. + */ + +static int cups_job_delete(const char *sharename, const char *lprm_command, struct printjob *pjob) +{ + TALLOC_CTX *frame = talloc_stackframe(); + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char *user = NULL; + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + size_t size; + + DEBUG(5,("cups_job_delete(%s, %p (%d))\n", sharename, pjob, pjob->sysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build an IPP_CANCEL_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * job-uri + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_CANCEL_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/jobs/%d", + pjob->sysjob); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); + + if (!push_utf8_talloc(frame, &user, pjob->user, &size)) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, user); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + return ret; +} + + +/* + * 'cups_job_pause()' - Pause a job. + */ + +static int cups_job_pause(int snum, struct printjob *pjob) +{ + TALLOC_CTX *frame = talloc_stackframe(); + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char *user = NULL; + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + size_t size; + + DEBUG(5,("cups_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build an IPP_HOLD_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * job-uri + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_HOLD_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/jobs/%d", + pjob->sysjob); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); + + if (!push_utf8_talloc(frame, &user, pjob->user, &size)) { + goto out; + } + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, user); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + return ret; +} + + +/* + * 'cups_job_resume()' - Resume a paused job. + */ + +static int cups_job_resume(int snum, struct printjob *pjob) +{ + TALLOC_CTX *frame = talloc_stackframe(); + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char *user = NULL; + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + size_t size; + + DEBUG(5,("cups_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build an IPP_RELEASE_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * job-uri + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_RELEASE_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/jobs/%d", + pjob->sysjob); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri); + + if (!push_utf8_talloc(frame, &user, pjob->user, &size)) { + goto out; + } + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, user); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + return ret; +} + + +/* + * 'cups_job_submit()' - Submit a job for printing. + */ + +static int cups_job_submit(int snum, struct printjob *pjob, + enum printing_types printing_type, + char *lpq_cmd) +{ + TALLOC_CTX *frame = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr_job_id = NULL; /* IPP Attribute "job-id" */ + cups_lang_t *language = NULL; /* Default language */ + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + char *new_jobname = NULL; + int num_options = 0; + cups_option_t *options = NULL; + char *printername = NULL; + char *user = NULL; + char *jobname = NULL; + char *cupsoptions = NULL; + char *filename = NULL; + size_t size; + + DEBUG(5,("cups_job_submit(%d, %p)\n", snum, pjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build an IPP_PRINT_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * requesting-user-name + * [document-data] + */ + + request = ippNew(); + + ippSetOperation(request, IPP_PRINT_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + if (!push_utf8_talloc(frame, &printername, + lp_printername(talloc_tos(), lp_sub, snum), + &size)) { + goto out; + } + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/printers/%s", + printername); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", NULL, uri); + + if (!push_utf8_talloc(frame, &user, pjob->user, &size)) { + goto out; + } + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, user); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, + "job-originating-host-name", NULL, + pjob->clientmachine); + + if (!push_utf8_talloc(frame, &jobname, pjob->jobname, &size)) { + goto out; + } + new_jobname = talloc_asprintf(frame, + "%s%.8u %s", PRINT_SPOOL_PREFIX, + pjob->jobid, jobname); + if (new_jobname == NULL) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL, + new_jobname); + + /* + * add any options defined in smb.conf + */ + + if (!push_utf8_talloc(frame, &cupsoptions, + lp_cups_options(talloc_tos(), lp_sub, snum), &size)) { + goto out; + } + num_options = 0; + options = NULL; + num_options = cupsParseOptions(cupsoptions, num_options, &options); + + if ( num_options ) + cupsEncodeOptions(request, num_options, options); + + /* + * Do the request and get back a response... + */ + + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/printers/%s", + printername); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + if (!push_utf8_talloc(frame, &filename, pjob->filename, &size)) { + goto out; + } + if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to print file to %s - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } else { + ret = 0; + attr_job_id = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER); + if(attr_job_id) { + pjob->sysjob = ippGetInteger(attr_job_id, 0); + DEBUG(5,("cups_job_submit: job-id %d\n", pjob->sysjob)); + } else { + DEBUG(0,("Missing job-id attribute in IPP response\n")); + } + } + } else { + DEBUG(0,("Unable to print file to `%s' - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } + + if ( ret == 0 ) + unlink(pjob->filename); + /* else print_job_end will do it for us */ + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + + return ret; +} + +/* + * 'cups_queue_get()' - Get all the jobs in the print queue. + */ + +static int cups_queue_get(const char *sharename, + enum printing_types printing_type, + char *lpq_command, + print_queue_struct **q, + print_status_struct *status) +{ + TALLOC_CTX *frame = talloc_stackframe(); + char *printername = NULL; + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr = NULL; /* Current attribute */ + cups_lang_t *language = NULL; /* Default language */ + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + int qcount = 0, /* Number of active queue entries */ + qalloc = 0; /* Number of queue entries allocated */ + print_queue_struct *queue = NULL, /* Queue entries */ + *temp; /* Temporary pointer for queue */ + char *user_name = NULL, /* job-originating-user-name attribute */ + *job_name = NULL; /* job-name attribute */ + int job_id; /* job-id attribute */ + int job_k_octets; /* job-k-octets attribute */ + time_t job_time; /* time-at-creation attribute */ + ipp_jstate_t job_status; /* job-status attribute */ + int job_priority; /* job-priority attribute */ + size_t size; + static const char *jattrs[] = /* Requested job attributes */ + { + "job-id", + "job-k-octets", + "job-name", + "job-originating-user-name", + "job-priority", + "job-state", + "time-at-creation", + }; + static const char *pattrs[] = /* Requested printer attributes */ + { + "printer-state", + "printer-state-message" + }; + + *q = NULL; + + /* HACK ALERT!!! The problem with support the 'printer name' + option is that we key the tdb off the sharename. So we will + overload the lpq_command string to pass in the printername + (which is basically what we do for non-cups printers ... using + the lpq_command to get the queue listing). */ + + if (!push_utf8_talloc(frame, &printername, lpq_command, &size)) { + goto out; + } + DEBUG(5,("cups_queue_get(%s, %p, %p)\n", lpq_command, q, status)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Generate the printer URI... + */ + + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/printers/%s", + printername); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + /* + * Build an IPP_GET_JOBS request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * requested-attributes + * printer-uri + */ + + request = ippNew(); + + ippSetOperation(request, IPP_GET_JOBS); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "requested-attributes", + (sizeof(jattrs) / sizeof(jattrs[0])), + NULL, jattrs); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", NULL, uri); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/")) == NULL) { + DEBUG(0,("Unable to get jobs for %s - %s\n", uri, + ippErrorString(cupsLastError()))); + goto out; + } + + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to get jobs for %s - %s\n", uri, + ippErrorString(ippGetStatusCode(response)))); + goto out; + } + + /* + * Process the jobs... + */ + + qcount = 0; + qalloc = 0; + queue = NULL; + + for (attr = ippFirstAttribute(response); attr != NULL; attr = ippNextAttribute(response)) { + /* + * Skip leading attributes until we hit a job... + */ + + while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_JOB) + attr = ippNextAttribute(response); + + if (attr == NULL) + break; + + /* + * Allocate memory as needed... + */ + if (qcount >= qalloc) { + qalloc += 16; + + queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc); + + if (queue == NULL) { + DEBUG(0,("cups_queue_get: Not enough memory!\n")); + qcount = 0; + goto out; + } + } + + temp = queue + qcount; + memset(temp, 0, sizeof(print_queue_struct)); + + /* + * Pull the needed attributes from this job... + */ + + job_id = 0; + job_priority = 50; + job_status = IPP_JOB_PENDING; + job_time = 0; + job_k_octets = 0; + user_name = NULL; + job_name = NULL; + + while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_JOB) { + if (ippGetName(attr) == NULL) { + attr = ippNextAttribute(response); + break; + } + + if (strcmp(ippGetName(attr), "job-id") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_id = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-k-octets") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_k_octets = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-priority") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_priority = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-state") == 0 && + ippGetValueTag(attr) == IPP_TAG_ENUM) + job_status = (ipp_jstate_t)ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "time-at-creation") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_time = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-name") == 0 && + ippGetValueTag(attr) == IPP_TAG_NAME) { + if (!pull_utf8_talloc(frame, + &job_name, + ippGetString(attr, 0, NULL), + &size)) { + goto out; + } + } + + if (strcmp(ippGetName(attr), "job-originating-user-name") == 0 && + ippGetValueTag(attr) == IPP_TAG_NAME) { + if (!pull_utf8_talloc(frame, + &user_name, + ippGetString(attr, 0, NULL), + &size)) { + goto out; + } + } + + attr = ippNextAttribute(response); + } + + /* + * See if we have everything needed... + */ + + if (user_name == NULL || job_name == NULL || job_id == 0) { + if (attr == NULL) + break; + else + continue; + } + + temp->sysjob = job_id; + temp->size = job_k_octets * 1024; + temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED : + job_status == IPP_JOB_STOPPED ? LPQ_PAUSED : + job_status == IPP_JOB_HELD ? LPQ_PAUSED : + LPQ_PRINTING; + temp->priority = job_priority; + temp->time = job_time; + strlcpy(temp->fs_user, user_name, sizeof(temp->fs_user)); + strlcpy(temp->fs_file, job_name, sizeof(temp->fs_file)); + + qcount ++; + + if (attr == NULL) + break; + } + + ippDelete(response); + response = NULL; + + /* + * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the + * following attributes: + * + * attributes-charset + * attributes-natural-language + * requested-attributes + * printer-uri + */ + + request = ippNew(); + + ippSetOperation(request, IPP_GET_PRINTER_ATTRIBUTES); + ippSetRequestId(request, 1); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME, + "requested-attributes", + (sizeof(pattrs) / sizeof(pattrs[0])), + NULL, pattrs); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", NULL, uri); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/")) == NULL) { + DEBUG(0,("Unable to get printer status for %s - %s\n", printername, + ippErrorString(cupsLastError()))); + goto out; + } + + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to get printer status for %s - %s\n", printername, + ippErrorString(ippGetStatusCode(response)))); + goto out; + } + + /* + * Get the current printer status and convert it to the SAMBA values. + */ + + if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) { + if (ippGetInteger(attr, 0) == IPP_PRINTER_STOPPED) + status->status = LPSTAT_STOPPED; + else + status->status = LPSTAT_OK; + } + + if ((attr = ippFindAttribute(response, "printer-state-message", + IPP_TAG_TEXT)) != NULL) { + char *msg = NULL; + if (!pull_utf8_talloc(frame, &msg, + ippGetString(attr, 0, NULL), + &size)) { + SAFE_FREE(queue); + qcount = 0; + goto out; + } + fstrcpy(status->message, msg); + } + + out: + + /* + * Return the job queue... + */ + + *q = queue; + + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + return qcount; +} + + +/* + * 'cups_queue_pause()' - Pause a print queue. + */ + +static int cups_queue_pause(int snum) +{ + TALLOC_CTX *frame = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char *printername = NULL; + char *username = NULL; + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + size_t size; + + DEBUG(5,("cups_queue_pause(%d)\n", snum)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build an IPP_PAUSE_PRINTER request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_PAUSE_PRINTER); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + if (!push_utf8_talloc(frame, &printername, + lp_printername(talloc_tos(), lp_sub, snum), &size)) { + goto out; + } + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/printers/%s", + printername); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); + + if (!push_utf8_talloc(frame, &username, current_user_info.unix_name, &size)) { + goto out; + } + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, username); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to pause printer %s - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to pause printer %s - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + return ret; +} + + +/* + * 'cups_queue_resume()' - Restart a print queue. + */ + +static int cups_queue_resume(int snum) +{ + TALLOC_CTX *frame = talloc_stackframe(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char *printername = NULL; + char *username = NULL; + char uri[HTTP_MAX_URI] = {0}; /* printer-uri attribute */ + http_uri_status_t ustatus; + size_t size; + + DEBUG(5,("cups_queue_resume(%d)\n", snum)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(cups_passwd_cb); + + /* + * Try to connect to the server... + */ + + if ((http = cups_connect(frame)) == NULL) { + goto out; + } + + /* + * Build an IPP_RESUME_PRINTER request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_RESUME_PRINTER); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + if (!push_utf8_talloc(frame, &printername, lp_printername(talloc_tos(), lp_sub, snum), + &size)) { + goto out; + } + ustatus = httpAssembleURIf(HTTP_URI_CODING_ALL, + uri, + sizeof(uri), + "ipp", + NULL, /* username */ + "localhost", + ippPort(), + "/printers/%s", + printername); + if (ustatus != HTTP_URI_STATUS_OK) { + goto out; + } + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); + + if (!push_utf8_talloc(frame, &username, current_user_info.unix_name, &size)) { + goto out; + } + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, username); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to resume printer %s - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to resume printer %s - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + TALLOC_FREE(frame); + return ret; +} + +/******************************************************************* + * CUPS printing interface definitions... + ******************************************************************/ + +struct printif cups_printif = +{ + PRINT_CUPS, + cups_queue_get, + cups_queue_pause, + cups_queue_resume, + cups_job_delete, + cups_job_pause, + cups_job_resume, + cups_job_submit, +}; + +#else + /* this keeps fussy compilers happy */ + void print_cups_dummy(void); + void print_cups_dummy(void) {} +#endif /* HAVE_CUPS */ diff --git a/source3/printing/print_generic.c b/source3/printing/print_generic.c new file mode 100644 index 0000000..8798a4c --- /dev/null +++ b/source3/printing/print_generic.c @@ -0,0 +1,358 @@ +/* + Unix SMB/CIFS implementation. + printing command routines + Copyright (C) Andrew Tridgell 1992-2000 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "printing.h" +#include "smbd/proto.h" +#include "source3/lib/substitute.h" + +extern userdom_struct current_user_info; + +/**************************************************************************** + Run a given print command + a null terminated list of value/substitute pairs is provided + for local substitution strings +****************************************************************************/ +static int print_run_command(int snum, const char* printername, bool do_sub, + const char *command, int *outfd, ...) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + char *syscmd; + char *arg; + int ret; + TALLOC_CTX *ctx = talloc_tos(); + va_list ap; + va_start(ap, outfd); + + /* check for a valid system printername and valid command to run */ + + if ( !printername || !*printername ) { + va_end(ap); + return -1; + } + + if (!command || !*command) { + va_end(ap); + return -1; + } + + syscmd = talloc_strdup(ctx, command); + if (!syscmd) { + va_end(ap); + return -1; + } + + DBG_DEBUG("Incoming command '%s'\n", syscmd); + + while ((arg = va_arg(ap, char *))) { + char *value = va_arg(ap,char *); + syscmd = talloc_string_sub(ctx, syscmd, arg, value); + if (!syscmd) { + va_end(ap); + return -1; + } + } + va_end(ap); + + syscmd = talloc_string_sub(ctx, syscmd, "%p", printername); + if (!syscmd) { + return -1; + } + + syscmd = lpcfg_substituted_string(ctx, lp_sub, syscmd); + if (syscmd == NULL) { + return -1; + } + + if (do_sub && snum != -1) { + syscmd = talloc_sub_advanced(ctx, + lp_servicename(talloc_tos(), lp_sub, snum), + current_user_info.unix_name, + "", + get_current_gid(NULL), + syscmd); + if (!syscmd) { + return -1; + } + } + + ret = smbrun_no_sanitize(syscmd, outfd, NULL); + + DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret)); + + return ret; +} + + +/**************************************************************************** +delete a print job +****************************************************************************/ +static int generic_job_delete( const char *sharename, const char *lprm_command, struct printjob *pjob) +{ + fstring jobstr; + + /* need to delete the spooled entry */ + fstr_sprintf(jobstr, "%d", pjob->sysjob); + return print_run_command( -1, sharename, False, lprm_command, NULL, + "%j", jobstr, + "%T", http_timestring(talloc_tos(), pjob->starttime), + NULL); +} + +/**************************************************************************** +pause a job +****************************************************************************/ +static int generic_job_pause(int snum, struct printjob *pjob) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + fstring jobstr; + + /* need to pause the spooled entry */ + fstr_sprintf(jobstr, "%d", pjob->sysjob); + return print_run_command(snum, lp_printername(talloc_tos(), lp_sub, snum), True, + lp_lppause_command(snum), NULL, + "%j", jobstr, + NULL); +} + +/**************************************************************************** +resume a job +****************************************************************************/ +static int generic_job_resume(int snum, struct printjob *pjob) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + fstring jobstr; + + /* need to pause the spooled entry */ + fstr_sprintf(jobstr, "%d", pjob->sysjob); + return print_run_command(snum, lp_printername(talloc_tos(), lp_sub, snum), True, + lp_lpresume_command(snum), NULL, + "%j", jobstr, + NULL); +} + +/**************************************************************************** +get the current list of queued jobs +****************************************************************************/ +static int generic_queue_get(const char *printer_name, + enum printing_types printing_type, + char *lpq_command, + print_queue_struct **q, + print_status_struct *status) +{ + char **qlines; + int fd; + int numlines, i, qcount; + print_queue_struct *queue = NULL; + + /* never do substitution when running the 'lpq command' since we can't + get it right when using the background update daemon. Make the caller + do it before passing off the command string to us here. */ + + print_run_command(-1, printer_name, False, lpq_command, &fd, NULL); + + if (fd == -1) { + DEBUG(5,("generic_queue_get: Can't read print queue status for printer %s\n", + printer_name )); + return 0; + } + + numlines = 0; + qlines = fd_lines_load(fd, &numlines,0,NULL); + close(fd); + + /* turn the lpq output into a series of job structures */ + qcount = 0; + ZERO_STRUCTP(status); + if (numlines && qlines) { + queue = SMB_MALLOC_ARRAY(print_queue_struct, numlines+1); + if (!queue) { + TALLOC_FREE(qlines); + *q = NULL; + return 0; + } + memset(queue, '\0', sizeof(print_queue_struct)*(numlines+1)); + + for (i=0; ifilename); + if (!print_directory) { + return -1; + } + p = strrchr_m(print_directory,'/'); + if (!p) { + return -1; + } + *p++ = 0; + + if (chdir(print_directory) != 0) { + return -1; + } + + jobname = talloc_strdup(ctx, pjob->jobname); + if (!jobname) { + ret = -1; + goto out; + } + jobname = talloc_string_sub(ctx, jobname, "'", "_"); + if (!jobname) { + ret = -1; + goto out; + } + fstr_sprintf(job_page_count, "%d", pjob->page_count); + fstr_sprintf(job_size, "%zu", pjob->size); + + /* send it to the system spooler */ + ret = print_run_command(snum, lp_printername(talloc_tos(), lp_sub, snum), True, + lp_print_command(snum), NULL, + "%s", p, + "%J", jobname, + "%f", p, + "%z", job_size, + "%c", job_page_count, + NULL); + if (ret != 0) { + ret = -1; + goto out; + } + + /* + * check the queue for the newly submitted job, this allows us to + * determine the backend job identifier (sysjob). + */ + pjob->sysjob = -1; + ret = generic_queue_get(lp_printername(talloc_tos(), lp_sub, snum), + printing_type, lpq_cmd, &q, &status); + if (ret > 0) { + int i; + for (i = 0; i < ret; i++) { + if (strcmp(q[i].fs_file, p) == 0) { + pjob->sysjob = q[i].sysjob; + DEBUG(5, ("new job %u (%s) matches sysjob %d\n", + pjob->jobid, jobname, pjob->sysjob)); + break; + } + } + SAFE_FREE(q); + ret = 0; + } + if (pjob->sysjob == -1) { + DEBUG(2, ("failed to get sysjob for job %u (%s), tracking as " + "Unix job\n", pjob->jobid, jobname)); + } + + + out: + + if (chdir(current_directory) == -1) { + smb_panic("chdir failed in generic_job_submit"); + } + TALLOC_FREE(current_directory); + return ret; +} + +/**************************************************************************** + pause a queue +****************************************************************************/ +static int generic_queue_pause(int snum) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + return print_run_command(snum, lp_printername(talloc_tos(), lp_sub, snum), True, + lp_queuepause_command(snum), NULL, NULL); +} + +/**************************************************************************** + resume a queue +****************************************************************************/ +static int generic_queue_resume(int snum) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + return print_run_command(snum, lp_printername(talloc_tos(), lp_sub, snum), True, + lp_queueresume_command(snum), NULL, NULL); +} + +/**************************************************************************** + * Generic printing interface definitions... + ***************************************************************************/ + +struct printif generic_printif = +{ + DEFAULT_PRINTING, + generic_queue_get, + generic_queue_pause, + generic_queue_resume, + generic_job_delete, + generic_job_pause, + generic_job_resume, + generic_job_submit, +}; + diff --git a/source3/printing/print_iprint.c b/source3/printing/print_iprint.c new file mode 100644 index 0000000..2b2215e --- /dev/null +++ b/source3/printing/print_iprint.c @@ -0,0 +1,1367 @@ +/* + * Support code for Novell iPrint using the Common UNIX Printing + * System ("CUPS") libraries + * + * Copyright 1999-2003 by Michael R Sweet. + * Portions Copyright 2005 by Joel J. Smith. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "includes.h" +#include "printing.h" +#include "printing/pcap.h" +#include "lib/util/string_wrappers.h" + +#ifdef HAVE_IPRINT +#include +#include + +#define OPERATION_NOVELL_LIST_PRINTERS 0x401A +#define OPERATION_NOVELL_MGMT 0x401C +#define NOVELL_SERVER_SYSNAME "sysname=" +#define NOVELL_SERVER_SYSNAME_NETWARE "NetWare IA32" +#define NOVELL_SERVER_VERSION_STRING "iprintserverversion=" +#define NOVELL_SERVER_VERSION_OES_SP1 33554432 + +#if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5) +#define HAVE_CUPS_1_6 1 +#endif + +#ifndef HAVE_CUPS_1_6 +#define ippGetCount(attr) attr->num_values +#define ippGetGroupTag(attr) attr->group_tag +#define ippGetName(attr) attr->name +#define ippGetValueTag(attr) attr->value_tag +#define ippGetStatusCode(ipp) ipp->request.status.status_code +#define ippGetBoolean(attr, element) attr->values[element].boolean +#define ippGetInteger(attr, element) attr->values[element].integer +#define ippGetString(attr, element, language) attr->values[element].string.text + +static ipp_attribute_t * +ippFirstAttribute(ipp_t *ipp) +{ + if (!ipp) + return (NULL); + return (ipp->current = ipp->attrs); +} + +static ipp_attribute_t * +ippNextAttribute(ipp_t *ipp) +{ + if (!ipp || !ipp->current) + return (NULL); + return (ipp->current = ipp->current->next); +} + +static int ippSetOperation(ipp_t *ipp, ipp_op_t op) +{ + ipp->request.op.operation_id = op; + return (1); +} + +static int ippSetRequestId(ipp_t *ipp, int request_id) +{ + ipp->request.any.request_id = request_id; + return (1); +} +#endif + +/* + * 'iprint_passwd_cb()' - The iPrint password callback... + */ + +static const char * /* O - Password or NULL */ +iprint_passwd_cb(const char *prompt) /* I - Prompt */ +{ + /* + * Always return NULL to indicate that no password is available... + */ + + return (NULL); +} + +static const char *iprint_server(void) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *server = lp_iprint_server(talloc_tos(), lp_sub); + + if ((server != NULL) && (strlen(server) > 0)) { + DEBUG(10, ("iprint server explicitly set to %s\n", + server)); + return server; + } + + DEBUG(10, ("iprint server left to default %s\n", cupsServer())); + return cupsServer(); +} + +/* + * Pass in an already connected http_t* + * Returns the server version if one can be found, multiplied by + * -1 for all NetWare versions. Returns 0 if a server version + * cannot be determined + */ + +static int iprint_get_server_version(http_t *http, char* serviceUri) +{ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr; /* Current attribute */ + cups_lang_t *language = NULL; /* Default language */ + char *ver; /* server version pointer */ + char *vertmp; /* server version tmp pointer */ + int serverVersion = 0; /* server version */ + char *os; /* server os */ + int osFlag = 0; /* 0 for NetWare, 1 for anything else */ + char *temp; /* pointer for string manipulation */ + + /* + * Build an OPERATION_NOVELL_MGMT("get-server-version") request, + * which requires the following attributes: + * + * attributes-charset + * attributes-natural-language + * operation-name + * service-uri + */ + + request = ippNew(); + + ippSetOperation(request, (ipp_op_t)OPERATION_NOVELL_MGMT); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "service-uri", NULL, serviceUri); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "operation-name", NULL, "get-server-version"); + + /* + * Do the request and get back a response... + */ + + if (((response = cupsDoRequest(http, request, "/ipp/")) == NULL) || + (ippGetStatusCode(response) >= IPP_OK_CONFLICT)) + goto out; + + if (((attr = ippFindAttribute(response, "server-version", + IPP_TAG_STRING)) != NULL)) { + if ((ver = strstr(ippGetString(attr, 0, NULL), + NOVELL_SERVER_VERSION_STRING)) != NULL) { + ver += strlen(NOVELL_SERVER_VERSION_STRING); + /* + * Strangely, libcups stores a IPP_TAG_STRING (octet + * string) as a null-terminated string with no length + * even though it could be binary data with nulls in + * it. Luckily, in this case the value is not binary. + */ + serverVersion = strtol(ver, &vertmp, 10); + + /* Check for not found, overflow or negative version */ + if ((ver == vertmp) || (serverVersion < 0)) + serverVersion = 0; + } + + if ((os = strstr(ippGetString(attr, 0, NULL), + NOVELL_SERVER_SYSNAME)) != NULL) { + os += strlen(NOVELL_SERVER_SYSNAME); + if ((temp = strchr(os,'<')) != NULL) + *temp = '\0'; + if (strcmp(os,NOVELL_SERVER_SYSNAME_NETWARE)) + osFlag = 1; /* 1 for non-NetWare systems */ + } + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (osFlag == 0) + serverVersion *= -1; + + return serverVersion; +} + + +static int iprint_cache_add_printer(http_t *http, + int reqId, + const char *url, + struct pcap_cache **pcache) +{ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr; /* Current attribute */ + cups_lang_t *language = NULL; /* Default language */ + const char *name, /* printer-name attribute */ + *info; /* printer-info attribute */ + char smb_enabled, /* smb-enabled attribute */ + secure; /* security-enabled attrib. */ + + const char *httpPath; /* path portion of the printer-uri */ + + static const char *pattrs[] = /* Requested printer attributes */ + { + "printer-name", + "security-enabled", + "printer-info", + "smb-enabled" + }; + + request = ippNew(); + + ippSetOperation(request, IPP_GET_PRINTER_ATTRIBUTES); + ippSetRequestId(request, reqId); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, url); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "requested-attributes", + (sizeof(pattrs) / sizeof(pattrs[0])), + NULL, pattrs); + + /* + * Do the request and get back a response... + */ + + if ((httpPath = strstr(url,"://")) == NULL || + (httpPath = strchr(httpPath+3,'/')) == NULL) + { + ippDelete(request); + request = NULL; + goto out; + } + + if ((response = cupsDoRequest(http, request, httpPath)) == NULL) { + ipp_status_t lastErr = cupsLastError(); + + /* + * Ignore printers that cannot be queried without credentials + */ + if (lastErr == IPP_FORBIDDEN || + lastErr == IPP_NOT_AUTHENTICATED || + lastErr == IPP_NOT_AUTHORIZED) + goto out; + + DEBUG(0,("Unable to get printer list - %s\n", + ippErrorString(lastErr))); + goto out; + } + + for (attr = ippFirstAttribute(response); attr != NULL;) { + /* + * Skip leading attributes until we hit a printer... + */ + + while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER) + attr = ippNextAttribute(response); + + if (attr == NULL) + break; + + /* + * Pull the needed attributes from this printer... + */ + + name = NULL; + info = NULL; + smb_enabled= 1; + secure = 0; + + while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER) { + if (strcmp(ippGetName(attr), "printer-name") == 0 && + ippGetValueTag(attr) == IPP_TAG_NAME) + name = ippGetString(attr, 0, NULL); + + if (strcmp(ippGetName(attr), "printer-info") == 0 && + (ippGetValueTag(attr) == IPP_TAG_TEXT || + ippGetValueTag(attr) == IPP_TAG_TEXTLANG)) + info = ippGetString(attr, 0, NULL); + + /* + * If the smb-enabled attribute is present and the + * value is set to 0, don't show the printer. + * If the attribute is not present, assume that the + * printer should show up + */ + if (!strcmp(ippGetName(attr), "smb-enabled") && + ((ippGetValueTag(attr) == IPP_TAG_INTEGER && + !ippGetInteger(attr, 0)) || + (ippGetValueTag(attr) == IPP_TAG_BOOLEAN && + !ippGetBoolean(attr, 0)))) + smb_enabled = 0; + + /* + * If the security-enabled attribute is present and the + * value is set to 1, don't show the printer. + * If the attribute is not present, assume that the + * printer should show up + */ + if (!strcmp(ippGetName(attr), "security-enabled") && + ((ippGetValueTag(attr) == IPP_TAG_INTEGER && + ippGetInteger(attr, 0)) || + (ippGetValueTag(attr) == IPP_TAG_BOOLEAN && + ippGetBoolean(attr, 0)))) + secure = 1; + + attr = ippNextAttribute(response); + } + + /* + * See if we have everything needed... + * Make sure the printer is not a secure printer + * and make sure smb printing hasn't been explicitly + * disabled for the printer + */ + + if (name != NULL && !secure && smb_enabled) + pcap_cache_add_specific(pcache, name, info, NULL); + } + + out: + if (response) + ippDelete(response); + return(0); +} + +bool iprint_cache_reload(struct pcap_cache **_pcache) +{ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr; /* Current attribute */ + cups_lang_t *language = NULL; /* Default language */ + int i; + bool ret = false; + struct pcap_cache *pcache = NULL; + + DEBUG(5, ("reloading iprint printcap cache\n")); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(iprint_passwd_cb); + + /* + * Try to connect to the server... + */ + +#ifdef HAVE_HTTPCONNECT2 + http = httpConnect2(iprint_server(), + ippPort(), + NULL, + AF_UNSPEC, + HTTP_ENCRYPTION_NEVER, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#else + http = httpConnect(iprint_server(), ippPort()); +#endif + if (http == NULL) { + DEBUG(0,("Unable to connect to iPrint server %s - %s\n", + iprint_server(), strerror(errno))); + goto out; + } + + /* + * Build a OPERATION_NOVELL_LIST_PRINTERS request, which requires the following attributes: + * + * attributes-charset + * attributes-natural-language + */ + + request = ippNew(); + + ippSetOperation(request, (ipp_op_t)OPERATION_NOVELL_LIST_PRINTERS); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "ipp-server", NULL, "ippSrvr"); + + /* + * Do the request and get back a response... + */ + + if ((response = cupsDoRequest(http, request, "/ipp")) == NULL) { + DEBUG(0,("Unable to get printer list - %s\n", + ippErrorString(cupsLastError()))); + goto out; + } + + for (attr = ippFirstAttribute(response); attr != NULL;) { + /* + * Skip leading attributes until we hit a printer... + */ + + while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER) + attr = ippNextAttribute(response); + + if (attr == NULL) + break; + + /* + * Pull the needed attributes from this printer... + */ + + while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER) + { + if (strcmp(ippGetName(attr), "printer-name") == 0 && + (ippGetValueTag(attr) == IPP_TAG_URI || + ippGetValueTag(attr) == IPP_TAG_NAME || + ippGetValueTag(attr) == IPP_TAG_TEXT || + ippGetValueTag(attr) == IPP_TAG_NAMELANG || + ippGetValueTag(attr) == IPP_TAG_TEXTLANG)) + { + for (i = 0; isysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(iprint_passwd_cb); + + /* + * Try to connect to the server... + */ + +#ifdef HAVE_HTTPCONNECT2 + http = httpConnect2(iprint_server(), + ippPort(), + NULL, + AF_UNSPEC, + HTTP_ENCRYPTION_NEVER, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#else + http = httpConnect(iprint_server(), ippPort()); +#endif + if (http == NULL) { + DEBUG(0,("Unable to connect to iPrint server %s - %s\n", + iprint_server(), strerror(errno))); + goto out; + } + + /* + * Build an IPP_CANCEL_JOB request, which uses the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * job-id + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_CANCEL_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), sharename); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); + + ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, pjob->user); + + /* + * Do the request and get back a response... + */ + + slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", sharename); + + if ((response = cupsDoRequest(http, request, httpPath)) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + return ret; +} + + +/* + * 'iprint_job_pause()' - Pause a job. + */ + +static int iprint_job_pause(int snum, struct printjob *pjob) +{ + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char uri[HTTP_MAX_URI]; /* printer-uri attribute */ + char httpPath[HTTP_MAX_URI]; /* path portion of the printer-uri */ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + + DEBUG(5,("iprint_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(iprint_passwd_cb); + + /* + * Try to connect to the server... + */ + +#ifdef HAVE_HTTPCONNECT2 + http = httpConnect2(iprint_server(), + ippPort(), + NULL, + AF_UNSPEC, + HTTP_ENCRYPTION_NEVER, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#else + http = httpConnect(iprint_server(), ippPort()); +#endif + if (http == NULL) { + DEBUG(0,("Unable to connect to iPrint server %s - %s\n", + iprint_server(), strerror(errno))); + goto out; + } + + /* + * Build an IPP_HOLD_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * job-id + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_HOLD_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), + lp_printername(talloc_tos(), lp_sub, snum)); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); + + ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, pjob->user); + + /* + * Do the request and get back a response... + */ + + slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", + lp_printername(talloc_tos(), lp_sub, snum)); + + if ((response = cupsDoRequest(http, request, httpPath)) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + return ret; +} + + +/* + * 'iprint_job_resume()' - Resume a paused job. + */ + +static int iprint_job_resume(int snum, struct printjob *pjob) +{ + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + cups_lang_t *language = NULL; /* Default language */ + char uri[HTTP_MAX_URI]; /* printer-uri attribute */ + char httpPath[HTTP_MAX_URI]; /* path portion of the printer-uri */ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + + DEBUG(5,("iprint_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(iprint_passwd_cb); + + /* + * Try to connect to the server... + */ + +#ifdef HAVE_HTTPCONNECT2 + http = httpConnect2(iprint_server(), + ippPort(), + NULL, + AF_UNSPEC, + HTTP_ENCRYPTION_NEVER, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#else + http = httpConnect(iprint_server(), ippPort()); +#endif + if (http == NULL) { + DEBUG(0,("Unable to connect to iPrint server %s - %s\n", + iprint_server(), strerror(errno))); + goto out; + } + + /* + * Build an IPP_RELEASE_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * job-id + * requesting-user-name + */ + + request = ippNew(); + + ippSetOperation(request, IPP_RELEASE_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), + lp_printername(talloc_tos(), lp_sub, snum)); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); + + ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, pjob->user); + + /* + * Do the request and get back a response... + */ + + slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", + lp_printername(talloc_tos(), lp_sub, snum)); + + if ((response = cupsDoRequest(http, request, httpPath)) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob, + ippErrorString(cupsLastError()))); + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + return ret; +} + + +/* + * 'iprint_job_submit()' - Submit a job for printing. + */ + +static int iprint_job_submit(int snum, struct printjob *pjob, + enum printing_types printing_type, + char *lpq_cmd) +{ + int ret = 1; /* Return value */ + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr; /* Current attribute */ + cups_lang_t *language = NULL; /* Default language */ + char uri[HTTP_MAX_URI]; /* printer-uri attribute */ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + DEBUG(5,("iprint_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(iprint_passwd_cb); + + /* + * Try to connect to the server... + */ + +#ifdef HAVE_HTTPCONNECT2 + http = httpConnect2(iprint_server(), + ippPort(), + NULL, + AF_UNSPEC, + HTTP_ENCRYPTION_NEVER, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#else + http = httpConnect(iprint_server(), ippPort()); +#endif + if (http == NULL) { + DEBUG(0,("Unable to connect to iPrint server %s - %s\n", + iprint_server(), strerror(errno))); + goto out; + } + + /* + * Build an IPP_PRINT_JOB request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * printer-uri + * requesting-user-name + * [document-data] + */ + + request = ippNew(); + + ippSetOperation(request, IPP_PRINT_JOB); + ippSetRequestId(request, 1); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), + lp_printername(talloc_tos(), lp_sub, snum)); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", NULL, uri); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", + NULL, pjob->user); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, + "job-originating-host-name", NULL, + pjob->clientmachine); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL, + pjob->jobname); + + /* + * Do the request and get back a response... + */ + + slprintf(uri, sizeof(uri) - 1, "/ipp/%s", lp_printername(talloc_tos(), lp_sub, snum)); + + if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) { + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to print file to %s - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } else { + ret = 0; + } + } else { + DEBUG(0,("Unable to print file to `%s' - %s\n", + lp_printername(talloc_tos(), lp_sub, snum), + ippErrorString(cupsLastError()))); + } + + if ( ret == 0 ) + unlink(pjob->filename); + /* else print_job_end will do it for us */ + + if ( ret == 0 ) { + + attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER); + if (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_JOB) + { + pjob->sysjob = ippGetInteger(attr, 0); + } + } + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + return ret; +} + +/* + * 'iprint_queue_get()' - Get all the jobs in the print queue. + */ + +static int iprint_queue_get(const char *sharename, + enum printing_types printing_type, + char *lpq_command, + print_queue_struct **q, + print_status_struct *status) +{ + fstring printername; + http_t *http = NULL; /* HTTP connection to server */ + ipp_t *request = NULL, /* IPP Request */ + *response = NULL; /* IPP Response */ + ipp_attribute_t *attr = NULL; /* Current attribute */ + cups_lang_t *language = NULL; /* Default language */ + char uri[HTTP_MAX_URI]; /* printer-uri attribute */ + char serviceUri[HTTP_MAX_URI]; /* service-uri attribute */ + char httpPath[HTTP_MAX_URI]; /* path portion of the uri */ + int jobUseUnixTime = 0; /* Whether job times should + * be assumed to be Unix time */ + int qcount = 0, /* Number of active queue entries */ + qalloc = 0; /* Number of queue entries allocated */ + print_queue_struct *queue = NULL, /* Queue entries */ + *temp; /* Temporary pointer for queue */ + const char *user_name, /* job-originating-user-name attribute */ + *job_name; /* job-name attribute */ + int job_id; /* job-id attribute */ + int job_k_octets; /* job-k-octets attribute */ + time_t job_time; /* time-at-creation attribute */ + time_t printer_up_time = 0; /* printer's uptime */ + ipp_jstate_t job_status; /* job-status attribute */ + int job_priority; /* job-priority attribute */ + static const char *jattrs[] = /* Requested job attributes */ + { + "job-id", + "job-k-octets", + "job-name", + "job-originating-user-name", + "job-priority", + "job-state", + "time-at-creation", + }; + static const char *pattrs[] = /* Requested printer attributes */ + { + "printer-state", + "printer-state-message", + "printer-current-time", + "printer-up-time" + }; + + *q = NULL; + + /* HACK ALERT!!! The problem with support the 'printer name' + option is that we key the tdb off the sharename. So we will + overload the lpq_command string to pass in the printername + (which is basically what we do for non-cups printers ... using + the lpq_command to get the queue listing). */ + + fstrcpy( printername, lpq_command ); + + DEBUG(5,("iprint_queue_get(%s, %p, %p)\n", printername, q, status)); + + /* + * Make sure we don't ask for passwords... + */ + + cupsSetPasswordCB(iprint_passwd_cb); + + /* + * Try to connect to the server... + */ + +#ifdef HAVE_HTTPCONNECT2 + http = httpConnect2(iprint_server(), + ippPort(), + NULL, + AF_UNSPEC, + HTTP_ENCRYPTION_NEVER, + 1, /* blocking */ + 30 * 1000, /* timeout */ + NULL); +#else + http = httpConnect(iprint_server(), ippPort()); +#endif + if (http == NULL) { + DEBUG(0,("Unable to connect to iPrint server %s - %s\n", + iprint_server(), strerror(errno))); + goto out; + } + + /* + * Generate the printer URI and the service URI that goes with it... + */ + + slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), printername); + slprintf(serviceUri, sizeof(serviceUri) - 1, "ipp://%s/ipp/", iprint_server()); + + /* + * For Linux iPrint servers from OES SP1 on, the iPrint server + * uses Unix time for job start times unless it detects the iPrint + * client in an http User-Agent header. (This was done to accommodate + * CUPS broken behavior. According to RFC 2911, section 4.3.14, job + * start times are supposed to be relative to how long the printer has + * been up.) Since libcups doesn't allow us to set that header before + * the request is sent, this ugly hack allows us to detect the server + * version and decide how to interpret the job time. + */ + if (iprint_get_server_version(http, serviceUri) >= + NOVELL_SERVER_VERSION_OES_SP1) + jobUseUnixTime = 1; + + request = ippNew(); + + ippSetOperation(request, IPP_GET_PRINTER_ATTRIBUTES); + ippSetRequestId(request, 2); + + language = cupsLangDefault(); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", NULL, uri); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "requested-attributes", + (sizeof(pattrs) / sizeof(pattrs[0])), + NULL, pattrs); + + /* + * Do the request and get back a response... + */ + + slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername); + + if ((response = cupsDoRequest(http, request, httpPath)) == NULL) { + DEBUG(0,("Unable to get printer status for %s - %s\n", printername, + ippErrorString(cupsLastError()))); + *q = queue; + goto out; + } + + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to get printer status for %s - %s\n", printername, + ippErrorString(ippGetStatusCode(response)))); + *q = queue; + goto out; + } + + /* + * Get the current printer status and convert it to the SAMBA values. + */ + + if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) { + if (ippGetInteger(attr, 0) == IPP_PRINTER_STOPPED) + status->status = LPSTAT_STOPPED; + else + status->status = LPSTAT_OK; + } + + if ((attr = ippFindAttribute(response, "printer-state-message", + IPP_TAG_TEXT)) != NULL) + fstrcpy(status->message, ippGetString(attr, 0, NULL)); + + if ((attr = ippFindAttribute(response, "printer-up-time", + IPP_TAG_INTEGER)) != NULL) + printer_up_time = ippGetInteger(attr, 0); + + ippDelete(response); + response = NULL; + + /* + * Build an IPP_GET_JOBS request, which requires the following + * attributes: + * + * attributes-charset + * attributes-natural-language + * requested-attributes + * printer-uri + */ + + request = ippNew(); + + ippSetOperation(request, IPP_GET_JOBS); + ippSetRequestId(request, 3); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET, + "attributes-charset", NULL, "utf-8"); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, + "attributes-natural-language", NULL, language->language); + + ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", NULL, uri); + + ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "requested-attributes", + (sizeof(jattrs) / sizeof(jattrs[0])), + NULL, jattrs); + + /* + * Do the request and get back a response... + */ + + slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername); + + if ((response = cupsDoRequest(http, request, httpPath)) == NULL) { + DEBUG(0,("Unable to get jobs for %s - %s\n", uri, + ippErrorString(cupsLastError()))); + goto out; + } + + if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) { + DEBUG(0,("Unable to get jobs for %s - %s\n", uri, + ippErrorString(ippGetStatusCode(response)))); + goto out; + } + + /* + * Process the jobs... + */ + + qcount = 0; + qalloc = 0; + queue = NULL; + + for (attr = ippFirstAttribute(response); attr != NULL; attr = ippNextAttribute(response)) { + /* + * Skip leading attributes until we hit a job... + */ + + while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_JOB) + attr = ippNextAttribute(response); + + if (attr == NULL) + break; + + /* + * Allocate memory as needed... + */ + if (qcount >= qalloc) { + qalloc += 16; + + queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc); + + if (queue == NULL) { + DEBUG(0,("iprint_queue_get: Not enough memory!\n")); + qcount = 0; + goto out; + } + } + + temp = queue + qcount; + memset(temp, 0, sizeof(print_queue_struct)); + + /* + * Pull the needed attributes from this job... + */ + + job_id = 0; + job_priority = 50; + job_status = IPP_JOB_PENDING; + job_time = 0; + job_k_octets = 0; + user_name = NULL; + job_name = NULL; + + while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_JOB) { + if (ippGetName(attr) == NULL) { + attr = ippNextAttribute(response); + break; + } + + if (strcmp(ippGetName(attr), "job-id") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_id = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-k-octets") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_k_octets = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-priority") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + job_priority = ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "job-state") == 0 && + ippGetValueTag(attr) == IPP_TAG_ENUM) + job_status = (ipp_jstate_t)ippGetInteger(attr, 0); + + if (strcmp(ippGetName(attr), "time-at-creation") == 0 && + ippGetValueTag(attr) == IPP_TAG_INTEGER) + { + /* + * If jobs times are in Unix time, the accuracy of the job + * start time depends upon the iPrint server's time being + * set correctly. Otherwise, the accuracy depends upon + * the Samba server's time being set correctly + */ + + if (jobUseUnixTime) + job_time = ippGetInteger(attr, 0); + else + job_time = time(NULL) - printer_up_time + ippGetInteger(attr, 0); + } + + if (strcmp(ippGetName(attr), "job-name") == 0 && + (ippGetValueTag(attr) == IPP_TAG_NAMELANG || + ippGetValueTag(attr) == IPP_TAG_NAME)) + job_name = ippGetString(attr, 0, NULL); + + if (strcmp(ippGetName(attr), "job-originating-user-name") == 0 && + (ippGetValueTag(attr) == IPP_TAG_NAMELANG || + ippGetValueTag(attr) == IPP_TAG_NAME)) + user_name = ippGetString(attr, 0, NULL); + + attr = ippNextAttribute(response); + } + + /* + * See if we have everything needed... + */ + + if (user_name == NULL || job_name == NULL || job_id == 0) { + if (attr == NULL) + break; + else + continue; + } + + temp->sysjob = job_id; + temp->size = job_k_octets * 1024; + temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED : + job_status == IPP_JOB_STOPPED ? LPQ_PAUSED : + job_status == IPP_JOB_HELD ? LPQ_PAUSED : + LPQ_PRINTING; + temp->priority = job_priority; + temp->time = job_time; + strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1); + strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1); + + qcount ++; + + if (attr == NULL) + break; + } + + /* + * Return the job queue... + */ + + *q = queue; + + out: + if (response) + ippDelete(response); + + if (language) + cupsLangFree(language); + + if (http) + httpClose(http); + + return qcount; +} + + +/* + * 'iprint_queue_pause()' - Pause a print queue. + */ + +static int iprint_queue_pause(int snum) +{ + return(-1); /* Not supported without credentials */ +} + + +/* + * 'iprint_queue_resume()' - Restart a print queue. + */ + +static int iprint_queue_resume(int snum) +{ + return(-1); /* Not supported without credentials */ +} + +/******************************************************************* + * iPrint printing interface definitions... + ******************************************************************/ + +struct printif iprint_printif = +{ + PRINT_IPRINT, + iprint_queue_get, + iprint_queue_pause, + iprint_queue_resume, + iprint_job_delete, + iprint_job_pause, + iprint_job_resume, + iprint_job_submit, +}; + +#else + /* this keeps fussy compilers happy */ + void print_iprint_dummy(void); + void print_iprint_dummy(void) {} +#endif /* HAVE_IPRINT */ diff --git a/source3/printing/print_standard.c b/source3/printing/print_standard.c new file mode 100644 index 0000000..7cbdac7 --- /dev/null +++ b/source3/printing/print_standard.c @@ -0,0 +1,157 @@ +/* + Unix SMB/CIFS implementation. + printcap parsing + Copyright (C) Karl Auer 1993-1998 + + Re-working by Martin Kiff, 1994 + + Re-written again by Andrew Tridgell + + Modified for SVID support by Norm Jacobs, 1997 + + Modified for CUPS support by Michael Sweet, 1999 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + * This module contains code to parse and cache printcap data, possibly + * in concert with the CUPS/SYSV/AIX-specific code found elsewhere. + * + * The way this module looks at the printcap file is very simplistic. + * Only the local printcap file is inspected (no searching of NIS + * databases etc). + * + * There are assumed to be one or more printer names per record, held + * as a set of sub-fields separated by vertical bar symbols ('|') in the + * first field of the record. The field separator is assumed to be a colon + * ':' and the record separator a newline. + * + * Lines ending with a backspace '\' are assumed to flag that the following + * line is a continuation line so that a set of lines can be read as one + * printcap entry. + * + * A line stating with a hash '#' is assumed to be a comment and is ignored + * Comments are discarded before the record is strung together from the + * set of continuation lines. + * + * Opening a pipe for "lpc status" and reading that would probably + * be pretty effective. Code to do this already exists in the freely + * distributable PCNFS server code. + */ + +/* printcap parsing specific code moved here from printing/pcap.c */ + + +#include "includes.h" +#include "system/filesys.h" +#include "printing/pcap.h" + +/* handle standard printcap - moved from pcap_printer_fn() */ +bool std_pcap_cache_reload(const char *pcap_name, struct pcap_cache **_pcache) +{ + TALLOC_CTX *frame = talloc_stackframe(); + FILE *pcap_file; + char *pcap_line; + struct pcap_cache *pcache = NULL; + bool print_warning = false; + + if ((pcap_file = fopen(pcap_name, "r")) == NULL) { + DEBUG(0, ("Unable to open printcap file %s for read!\n", pcap_name)); + talloc_free(frame); + return false; + } + + while ((pcap_line = fgets_slash(frame, NULL, 1024, + pcap_file)) != NULL) { + char *name = NULL; + char *comment = NULL; + char *p, *q; + + if (*pcap_line == '#' || *pcap_line == 0) { + TALLOC_FREE(pcap_line); + continue; + } + + /* now we have a real printer line - cut at the first : */ + if ((p = strchr_m(pcap_line, ':')) != NULL) + *p = 0; + + /* + * now find the most likely printer name and comment + * this is pure guesswork, but it's better than nothing + */ + for (p = pcap_line; p != NULL; p = q) { + bool has_punctuation = false; + + if ((q = strchr_m(p, '|')) != NULL) + *q++ = 0; + + has_punctuation = (strchr_m(p, ' ') || + strchr_m(p, '\t') || + strchr_m(p, '"') || + strchr_m(p, '\'') || + strchr_m(p, ';') || + strchr_m(p, ',') || + strchr_m(p, '(') || + strchr_m(p, ')')); + + if (name == NULL && !has_punctuation) { + name = talloc_strdup(frame, p); + TALLOC_FREE(pcap_line); + continue; + } + + if (has_punctuation) { + comment = talloc_strdup(frame, p); + TALLOC_FREE(pcap_line); + continue; + } + } + + if (name != NULL) { + bool ok; + + if (!print_warning && strlen(name) > MAXPRINTERLEN) { + print_warning = true; + } + + ok = pcap_cache_add_specific(&pcache, + name, + comment, + NULL); + if (!ok) { + fclose(pcap_file); + pcap_cache_destroy_specific(&pcache); + talloc_free(frame); + return false; + } + } + TALLOC_FREE(name); + TALLOC_FREE(comment); + TALLOC_FREE(pcap_line); + } + + if (print_warning) { + DBG_WARNING("WARNING: You have some printer names that are " + "longer than %u characters. These may not be " + "accessible to some older clients!\n", + (unsigned int)MAXPRINTERLEN); + } + + fclose(pcap_file); + *_pcache = pcache; + talloc_free(frame); + return true; +} diff --git a/source3/printing/print_svid.c b/source3/printing/print_svid.c new file mode 100644 index 0000000..4006323 --- /dev/null +++ b/source3/printing/print_svid.c @@ -0,0 +1,148 @@ +/* + * Copyright (C) 1997-1998 by Norm Jacobs, Colorado Springs, Colorado, USA + * Copyright (C) 1997-1998 by Sun Microsystem, Inc. + * All Rights Reserved + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * This module implements support for gathering and comparing available + * printer information on a SVID or XPG4 compliant system. It does this + * through the use of the SVID/XPG4 command "lpstat(1)". + * + * The expectations is that execution of the command "lpstat -v" will + * generate responses in the form of: + * + * device for serial: /dev/term/b + * system for fax: server + * system for color: server (as printer chroma) + */ + + +#include "includes.h" +#include "printing/pcap.h" +#include "lib/util_file.h" + +#if defined(SYSV) || defined(HPUX) +bool sysv_cache_reload(struct pcap_cache **_pcache) +{ + char **lines; + int i; + struct pcap_cache *pcache = NULL; + char **argl = NULL; + +#if defined(HPUX) + DEBUG(5, ("reloading hpux printcap cache\n")); +#else + DEBUG(5, ("reloading sysv printcap cache\n")); +#endif + + argl = str_list_make_empty(talloc_tos()); + str_list_add_printf(&argl, "/usr/bin/lpstat"); + str_list_add_printf(&argl, "-v"); + if (argl == NULL) { + return false; + } + + lines = file_lines_ploadv(talloc_tos(), argl, NULL); + if (lines == NULL) { +#if defined(HPUX) + + /* + * if "lpstat -v" is NULL then we check if schedular is running if it is + * that means no printers are added on the HP-UX system, if schedular is not + * running we display reload error. + */ + + char **scheduler; + + argl[1] = talloc_strdup(argl, "-r"); + if (argl[1] == NULL) { + TALLOC_FREE(argl); + return false; + } + scheduler = file_lines_ploadv(talloc_tos(), argl, NULL); + TALLOC_FREE(argl); + if(!strcmp(*scheduler,"scheduler is running")){ + DEBUG(3,("No Printers found!!!\n")); + TALLOC_FREE(scheduler); + return True; + } + else{ + DEBUG(3,("Scheduler is not running!!!\n")); + TALLOC_FREE(scheduler); + return False; + } +#else + DEBUG(3,("No Printers found!!!\n")); + return False; +#endif + } + TALLOC_FREE(argl); + + for (i = 0; lines[i]; i++) { + char *name, *tmp; + char *buf = lines[i]; + + /* eat "system/device for " */ + if (((tmp = strchr_m(buf, ' ')) == NULL) || + ((tmp = strchr_m(++tmp, ' ')) == NULL)) + continue; + + /* + * In case we're only at the "for ". + */ + + if(!strncmp("for ", ++tmp, 4)) { + tmp=strchr_m(tmp, ' '); + tmp++; + } + + /* Eat whitespace. */ + + while(*tmp == ' ') + ++tmp; + + /* + * On HPUX there is an extra line that can be ignored. + * d.thibadeau 2001/08/09 + */ + if(!strncmp("remote to", tmp, 9)) + continue; + + name = tmp; + + /* truncate the ": ..." */ + if ((tmp = strchr_m(name, ':')) != NULL) + *tmp = '\0'; + + /* add it to the cache */ + if (!pcap_cache_add_specific(&pcache, name, NULL, NULL)) { + TALLOC_FREE(lines); + pcap_cache_destroy_specific(&pcache); + return false; + } + } + + TALLOC_FREE(lines); + *_pcache = pcache; + return true; +} + +#else +/* this keeps fussy compilers happy */ + void print_svid_dummy(void); + void print_svid_dummy(void) {} +#endif diff --git a/source3/printing/printer_list.c b/source3/printing/printer_list.c new file mode 100644 index 0000000..7fd07ed --- /dev/null +++ b/source3/printing/printer_list.c @@ -0,0 +1,460 @@ +/* + Unix SMB/CIFS implementation. + Share Database of available printers. + Copyright (C) Simo Sorce 2010 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_open.h" +#include "util_tdb.h" +#include "printer_list.h" + +#define PL_KEY_PREFIX "PRINTERLIST/PRN/" +#define PL_KEY_FORMAT PL_KEY_PREFIX"%s" +#define PL_TIMESTAMP_KEY "PRINTERLIST/GLOBAL/LAST_REFRESH" +#define PL_DATA_FORMAT "ddPPP" +#define PL_TSTAMP_FORMAT "dd" + +static struct db_context *printerlist_db; + +static struct db_context *get_printer_list_db(void) +{ + char *db_path; + + if (printerlist_db != NULL) { + return printerlist_db; + } + + db_path = lock_path(talloc_tos(), "printer_list.tdb"); + if (db_path == NULL) { + return NULL; + } + + printerlist_db = db_open(NULL, + db_path, + 0, + TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, + O_RDWR|O_CREAT, + 0644, + DBWRAP_LOCK_ORDER_1, + DBWRAP_FLAG_NONE); + TALLOC_FREE(db_path); + if (printerlist_db == NULL) { + DBG_ERR("Failed to open printer_list.tdb\n"); + } + return printerlist_db; +} + +NTSTATUS printer_list_get_printer(TALLOC_CTX *mem_ctx, + const char *name, + const char **comment, + const char **location, + time_t *last_refresh) +{ + struct db_context *db; + char *key; + TDB_DATA data; + uint32_t time_h, time_l; + char *nstr = NULL; + char *cstr = NULL; + char *lstr = NULL; + NTSTATUS status; + int ret; + + db = get_printer_list_db(); + if (db == NULL) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + key = talloc_asprintf(mem_ctx, PL_KEY_FORMAT, name); + if (!key) { + DEBUG(0, ("Failed to allocate key name!\n")); + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_fetch_bystring_upper(db, key, key, &data); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(6, ("Failed to fetch record! " + "The printer database is empty?\n")); + goto done; + } + + ret = tdb_unpack(data.dptr, data.dsize, + PL_DATA_FORMAT, + &time_h, &time_l, &nstr, &cstr, &lstr); + if (ret == -1) { + DEBUG(1, ("Failed to unpack printer data\n")); + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto done; + } + + if (last_refresh) { + *last_refresh = (time_t)(((uint64_t)time_h << 32) + time_l); + } + + if (comment) { + *comment = talloc_strdup(mem_ctx, cstr); + if (!*comment) { + DEBUG(1, ("Failed to strdup comment!\n")); + status = NT_STATUS_NO_MEMORY; + goto done; + } + } + + if (location) { + *location = talloc_strdup(mem_ctx, lstr); + if (*location == NULL) { + DEBUG(1, ("Failed to strdup location!\n")); + status = NT_STATUS_NO_MEMORY; + goto done; + } + } + + status = NT_STATUS_OK; + +done: + SAFE_FREE(nstr); + SAFE_FREE(cstr); + SAFE_FREE(lstr); + TALLOC_FREE(key); + return status; +} + +bool printer_list_printername_exists(const char *name) +{ + struct db_context *db = get_printer_list_db(); + char *key = NULL; + bool ok; + + if (db == NULL) { + return false; + } + + key = talloc_asprintf_strupper_m( + talloc_tos(), PL_KEY_FORMAT, name); + if (key == NULL) { + return false; + } + + ok = dbwrap_exists(db, string_term_tdb_data(key)); + TALLOC_FREE(key); + return ok; +} + +NTSTATUS printer_list_set_printer(TALLOC_CTX *mem_ctx, + const char *name, + const char *comment, + const char *location, + time_t last_refresh) +{ + struct db_context *db; + char *key; + TDB_DATA data; + uint64_t time_64; + uint32_t time_h, time_l; + NTSTATUS status; + int len; + + db = get_printer_list_db(); + if (db == NULL) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + key = talloc_asprintf(mem_ctx, PL_KEY_FORMAT, name); + if (!key) { + DEBUG(0, ("Failed to allocate key name!\n")); + return NT_STATUS_NO_MEMORY; + } + + if (comment == NULL) { + comment = ""; + } + + if (location == NULL) { + location = ""; + } + + time_64 = last_refresh; + time_l = time_64 & 0xFFFFFFFFL; + time_h = time_64 >> 32; + + len = tdb_pack(NULL, 0, + PL_DATA_FORMAT, + time_h, + time_l, + name, + comment, + location); + + data.dptr = talloc_array(key, uint8_t, len); + if (!data.dptr) { + DEBUG(0, ("Failed to allocate tdb data buffer!\n")); + status = NT_STATUS_NO_MEMORY; + goto done; + } + data.dsize = len; + + len = tdb_pack(data.dptr, data.dsize, + PL_DATA_FORMAT, + time_h, + time_l, + name, + comment, + location); + + status = dbwrap_store_bystring_upper(db, key, data, TDB_REPLACE); + +done: + TALLOC_FREE(key); + return status; +} + +NTSTATUS printer_list_get_last_refresh(time_t *last_refresh) +{ + struct db_context *db; + TDB_DATA data; + uint32_t time_h, time_l; + NTSTATUS status; + int ret; + + db = get_printer_list_db(); + if (db == NULL) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + ZERO_STRUCT(data); + + status = dbwrap_fetch_bystring(db, talloc_tos(), PL_TIMESTAMP_KEY, &data); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(1, ("Failed to fetch record!\n")); + goto done; + } + + ret = tdb_unpack(data.dptr, data.dsize, + PL_TSTAMP_FORMAT, &time_h, &time_l); + TALLOC_FREE(data.dptr); + if (ret == -1) { + DEBUG(1, ("Failed to unpack printer data\n")); + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto done; + } + + *last_refresh = (time_t)(((uint64_t)time_h << 32) + time_l); + status = NT_STATUS_OK; + +done: + return status; +} + +NTSTATUS printer_list_mark_reload(void) +{ + struct db_context *db; + TDB_DATA data; + uint32_t time_h, time_l; + time_t now = time_mono(NULL); + NTSTATUS status; + int len; + + db = get_printer_list_db(); + if (db == NULL) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + time_l = ((uint64_t)now) & 0xFFFFFFFFL; + time_h = ((uint64_t)now) >> 32; + + len = tdb_pack(NULL, 0, PL_TSTAMP_FORMAT, time_h, time_l); + + data.dptr = talloc_array(talloc_tos(), uint8_t, len); + if (!data.dptr) { + DEBUG(0, ("Failed to allocate tdb data buffer!\n")); + status = NT_STATUS_NO_MEMORY; + goto done; + } + data.dsize = len; + + len = tdb_pack(data.dptr, data.dsize, + PL_TSTAMP_FORMAT, time_h, time_l); + + status = dbwrap_store_bystring(db, PL_TIMESTAMP_KEY, + data, TDB_REPLACE); + +done: + TALLOC_FREE(data.dptr); + return status; +} + +typedef int (printer_list_trv_fn_t)(struct db_record *, void *); + +static NTSTATUS printer_list_traverse(printer_list_trv_fn_t *fn, + void *private_data, + bool read_only) +{ + struct db_context *db; + NTSTATUS status; + + db = get_printer_list_db(); + if (db == NULL) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + if (read_only) { + status = dbwrap_traverse_read(db, fn, private_data, NULL); + } else { + status = dbwrap_traverse(db, fn, private_data, NULL); + } + + return status; +} + +struct printer_list_clean_state { + time_t last_refresh; + NTSTATUS status; +}; + +static int printer_list_clean_fn(struct db_record *rec, void *private_data) +{ + struct printer_list_clean_state *state = + (struct printer_list_clean_state *)private_data; + uint32_t time_h, time_l; + time_t refresh; + char *name; + char *comment; + char *location; + int ret; + TDB_DATA key; + TDB_DATA value; + + key = dbwrap_record_get_key(rec); + + /* skip anything that does not contain PL_DATA_FORMAT data */ + if (strncmp((char *)key.dptr, + PL_KEY_PREFIX, sizeof(PL_KEY_PREFIX)-1)) { + return 0; + } + + value = dbwrap_record_get_value(rec); + + ret = tdb_unpack(value.dptr, value.dsize, + PL_DATA_FORMAT, &time_h, &time_l, &name, &comment, + &location); + if (ret == -1) { + DEBUG(1, ("Failed to unpack printer data\n")); + state->status = NT_STATUS_INTERNAL_DB_CORRUPTION; + return -1; + } + + SAFE_FREE(name); + SAFE_FREE(comment); + SAFE_FREE(location); + + refresh = (time_t)(((uint64_t)time_h << 32) + time_l); + + if (refresh < state->last_refresh) { + state->status = dbwrap_record_delete(rec); + if (!NT_STATUS_IS_OK(state->status)) { + return -1; + } + } + + return 0; +} + +NTSTATUS printer_list_clean_old(void) +{ + struct printer_list_clean_state state; + NTSTATUS status; + + status = printer_list_get_last_refresh(&state.last_refresh); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + state.status = NT_STATUS_OK; + + status = printer_list_traverse(printer_list_clean_fn, &state, false); + if (NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL) && + !NT_STATUS_IS_OK(state.status)) { + status = state.status; + } + + return status; +} + +struct printer_list_exec_state { + void (*fn)(const char *, const char *, const char *, void *); + void *private_data; + NTSTATUS status; +}; + +static int printer_list_exec_fn(struct db_record *rec, void *private_data) +{ + struct printer_list_exec_state *state = + (struct printer_list_exec_state *)private_data; + uint32_t time_h, time_l; + char *name; + char *comment; + char *location; + int ret; + TDB_DATA key; + TDB_DATA value; + + key = dbwrap_record_get_key(rec); + + /* always skip PL_TIMESTAMP_KEY key */ + if (strequal((const char *)key.dptr, PL_TIMESTAMP_KEY)) { + return 0; + } + + value = dbwrap_record_get_value(rec); + + ret = tdb_unpack(value.dptr, value.dsize, + PL_DATA_FORMAT, &time_h, &time_l, &name, &comment, + &location); + if (ret == -1) { + DEBUG(1, ("Failed to unpack printer data\n")); + state->status = NT_STATUS_INTERNAL_DB_CORRUPTION; + return -1; + } + + state->fn(name, comment, location, state->private_data); + + SAFE_FREE(name); + SAFE_FREE(comment); + SAFE_FREE(location); + return 0; +} + +NTSTATUS printer_list_read_run_fn(void (*fn)(const char *, const char *, const char *, void *), + void *private_data) +{ + struct printer_list_exec_state state; + NTSTATUS status; + + state.fn = fn; + state.private_data = private_data; + state.status = NT_STATUS_OK; + + status = printer_list_traverse(printer_list_exec_fn, &state, true); + if (NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL) && + !NT_STATUS_IS_OK(state.status)) { + status = state.status; + } + + return status; +} diff --git a/source3/printing/printer_list.h b/source3/printing/printer_list.h new file mode 100644 index 0000000..c687048 --- /dev/null +++ b/source3/printing/printer_list.h @@ -0,0 +1,105 @@ +/* + Unix SMB/CIFS implementation. + Share Database of available printers. + Copyright (C) Simo Sorce 2010 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef _PRINTER_LIST_H_ +#define _PRINTER_LIST_H_ + +/** + * @brief Get the comment and the last refresh time from the printer list + * database. + * + * @param[in] mem_ctx The talloc memory context to use. + * + * @param[in] name The printer name to lookup. + * + * @param[out] comment A pointer to store the comment of the printer. + * + * @param[out] location A pointer to store the location of the printer. + * + * @param[out] last_refresh A pointer to store the last refresh time of the + * printer. + * + * @return NT_STATUS_OK on success, a correspoining NTSTATUS error + * code on a failure. + */ +NTSTATUS printer_list_get_printer(TALLOC_CTX *mem_ctx, + const char *name, + const char **comment, + const char **location, + time_t *last_refresh); + +bool printer_list_printername_exists(const char *name); + +/** + * @brief Add a printer to the printer list database. + * + * @param[in] mem_ctx The talloc memory context to use. + * + * @param[in] name The printer name to store in the db. + * + * @param[in] comment The comment to store in the db. + * + * @param[in] location The location to store in the db. + * + * @param[in] last_refresh The last refresh time of the printer to store in + * the db. + * + * @return NT_STATUS_OK on success, a correspoining NTSTATUS error + * code on a failure. + */ +NTSTATUS printer_list_set_printer(TALLOC_CTX *mem_ctx, + const char *name, + const char *comment, + const char *location, + time_t last_refresh); + +/** + * @brief Get the time of the last refresh of the printer database. + * + * @param[out] last_refresh The last refresh time in the db. + * + * @return NT_STATUS_OK on success, a correspoining NTSTATUS error + * code on a failure. + */ +NTSTATUS printer_list_get_last_refresh(time_t *last_refresh); + +/** + * @brief Mark the database as reloaded. + * + * This sets the last refresh time to the current time. You can get the last + * reload/refresh time of the database with printer_list_get_last_refresh(). + * + * @return NT_STATUS_OK on success, a correspoining NTSTATUS error + * code on a failure. + */ +NTSTATUS printer_list_mark_reload(void); + +/** + * @brief Cleanup old entries in the database. + * + * Entries older than the last refresh times will be deleted. + * + * @return NT_STATUS_OK on success, a correspoining NTSTATUS error + * code on a failure. + */ +NTSTATUS printer_list_clean_old(void); + +NTSTATUS printer_list_read_run_fn(void (*fn)(const char *, const char *, const char *, void *), + void *private_data); +#endif /* _PRINTER_LIST_H_ */ diff --git a/source3/printing/printing.c b/source3/printing/printing.c new file mode 100644 index 0000000..70b2b11 --- /dev/null +++ b/source3/printing/printing.c @@ -0,0 +1,3266 @@ +/* + Unix SMB/Netbios implementation. + Version 3.0 + printing backend routines + Copyright (C) Andrew Tridgell 1992-2000 + Copyright (C) Jeremy Allison 2002 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "smbd/globals.h" +#include "system/syslog.h" +#include "system/filesys.h" +#include "printing.h" +#include "../librpc/gen_ndr/ndr_spoolss.h" +#include "nt_printing.h" +#include "../librpc/gen_ndr/netlogon.h" +#include "printing/notify.h" +#include "printing/pcap.h" +#include "printing/printer_list.h" +#include "printing/queue_process.h" +#include "serverid.h" +#include "smbd/smbd.h" +#include "auth.h" +#include "messages.h" +#include "util_tdb.h" +#include "lib/param/loadparm.h" +#include "lib/util/sys_rw_data.h" +#include "lib/util/string_wrappers.h" +#include "lib/global_contexts.h" +#include "source3/printing/rap_jobid.h" +#include "source3/lib/substitute.h" + +extern userdom_struct current_user_info; + +/* Current printer interface */ +static bool remove_from_jobs_added(const char* sharename, uint32_t jobid); + +static int get_queue_status(const char* sharename, print_status_struct *); + +/**************************************************************************** + Initialise the printing backend. Called once at startup before the fork(). +****************************************************************************/ + +bool print_backend_init(struct messaging_context *msg_ctx) +{ + const char *sversion = "INFO/version"; + int services = lp_numservices(); + int snum; + bool ok; + char *print_cache_path; + + print_cache_path = cache_path(talloc_tos(), "printing"); + if (print_cache_path == NULL) { + return false; + } + ok = directory_create_or_exist(print_cache_path, 0755); + TALLOC_FREE(print_cache_path); + if (!ok) { + return false; + } + + /* handle a Samba upgrade */ + + for (snum = 0; snum < services; snum++) { + struct tdb_print_db *pdb; + if (!lp_printable(snum)) + continue; + + pdb = get_print_db_byname(lp_const_servicename(snum)); + if (!pdb) + continue; + if (tdb_lock_bystring(pdb->tdb, sversion) != 0) { + DEBUG(0,("print_backend_init: Failed to open printer %s database\n", lp_const_servicename(snum) )); + release_print_db(pdb); + return False; + } + if (tdb_fetch_int32(pdb->tdb, sversion) != PRINT_DATABASE_VERSION) { + tdb_wipe_all(pdb->tdb); + tdb_store_int32(pdb->tdb, sversion, PRINT_DATABASE_VERSION); + } + tdb_unlock_bystring(pdb->tdb, sversion); + release_print_db(pdb); + } + + close_all_print_db(); /* Don't leave any open. */ + + /* do NT print initialization... */ + return nt_printing_init(msg_ctx); +} + +/**************************************************************************** + Shut down printing backend. Called once at shutdown to close the tdb. +****************************************************************************/ + +void printing_end(void) +{ + close_all_print_db(); /* Don't leave any open. */ +} + +/**************************************************************************** + Retrieve the set of printing functions for a given service. This allows + us to set the printer function table based on the value of the 'printing' + service parameter. + + Use the generic interface as the default and only use cups interface only + when asked for (and only when supported) +****************************************************************************/ + +static struct printif *get_printer_fns_from_type( enum printing_types type ) +{ + struct printif *printer_fns = &generic_printif; + +#ifdef HAVE_CUPS + if ( type == PRINT_CUPS ) { + printer_fns = &cups_printif; + } +#endif /* HAVE_CUPS */ + +#ifdef HAVE_IPRINT + if ( type == PRINT_IPRINT ) { + printer_fns = &iprint_printif; + } +#endif /* HAVE_IPRINT */ + + printer_fns->type = type; + + return printer_fns; +} + +static struct printif *get_printer_fns( int snum ) +{ + return get_printer_fns_from_type( (enum printing_types)lp_printing(snum) ); +} + + +/**************************************************************************** + Useful function to generate a tdb key. +****************************************************************************/ + +static TDB_DATA print_key(uint32_t jobid, uint32_t *tmp) +{ + TDB_DATA ret; + + SIVAL(tmp, 0, jobid); + ret.dptr = (uint8_t *)tmp; + ret.dsize = sizeof(*tmp); + return ret; +} + +/**************************************************************************** + Pack the devicemode to store it in a tdb. +****************************************************************************/ +static int pack_devicemode(struct spoolss_DeviceMode *devmode, uint8_t *buf, int buflen) +{ + enum ndr_err_code ndr_err; + DATA_BLOB blob = { .data = NULL }; + int len = 0; + + if (devmode) { + ndr_err = ndr_push_struct_blob(&blob, talloc_tos(), + devmode, + (ndr_push_flags_fn_t) + ndr_push_spoolss_DeviceMode); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + DEBUG(10, ("pack_devicemode: " + "error encoding spoolss_DeviceMode\n")); + goto done; + } + } + + len = tdb_pack(buf, buflen, "B", blob.length, blob.data); + + if (devmode) { + DEBUG(8, ("Packed devicemode [%s]\n", devmode->formname)); + } + +done: + return len; +} + +/**************************************************************************** + Unpack the devicemode to store it in a tdb. +****************************************************************************/ +static int unpack_devicemode(TALLOC_CTX *mem_ctx, + const uint8_t *buf, int buflen, + struct spoolss_DeviceMode **devmode) +{ + struct spoolss_DeviceMode *dm; + enum ndr_err_code ndr_err; + char *data = NULL; + uint32_t data_len = 0; + DATA_BLOB blob; + int len = 0; + + *devmode = NULL; + + len = tdb_unpack(buf, buflen, "B", &data_len, &data); + if (!data) { + return len; + } + + dm = talloc_zero(mem_ctx, struct spoolss_DeviceMode); + if (!dm) { + goto done; + } + + blob = data_blob_const(data, data_len); + + ndr_err = ndr_pull_struct_blob(&blob, dm, dm, + (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + DEBUG(10, ("unpack_devicemode: " + "error parsing spoolss_DeviceMode\n")); + goto done; + } + + DEBUG(8, ("Unpacked devicemode [%s](%s)\n", + dm->devicename, dm->formname)); + if (dm->driverextra_data.data) { + DEBUG(8, ("with a private section of %d bytes\n", + dm->__driverextra_length)); + } + + *devmode = dm; + +done: + SAFE_FREE(data); + return len; +} + +/*********************************************************************** + unpack a pjob from a tdb buffer +***********************************************************************/ + +static int unpack_pjob(TALLOC_CTX *mem_ctx, uint8_t *buf, int buflen, + struct printjob *pjob) +{ + int len = 0; + int used; + uint32_t pjpid, pjjobid, pjsysjob, pjfd, pjstarttime, pjstatus; + uint32_t pjsize, pjpage_count, pjspooled, pjsmbjob; + + if (!buf || !pjob) { + return -1; + } + + len += tdb_unpack(buf+len, buflen-len, "ddddddddddfffff", + &pjpid, + &pjjobid, + &pjsysjob, + &pjfd, + &pjstarttime, + &pjstatus, + &pjsize, + &pjpage_count, + &pjspooled, + &pjsmbjob, + pjob->filename, + pjob->jobname, + pjob->user, + pjob->clientmachine, + pjob->queuename); + + if (len == -1) { + return -1; + } + + used = unpack_devicemode(mem_ctx, buf+len, buflen-len, &pjob->devmode); + if (used == -1) { + return -1; + } + + len += used; + + pjob->pid = pjpid; + pjob->jobid = pjjobid; + pjob->sysjob = pjsysjob; + pjob->fd = pjfd; + pjob->starttime = pjstarttime; + pjob->status = pjstatus; + pjob->size = pjsize; + pjob->page_count = pjpage_count; + pjob->spooled = pjspooled; + pjob->smbjob = pjsmbjob; + + return len; + +} + +/**************************************************************************** + Useful function to find a print job in the database. +****************************************************************************/ + +static struct printjob *print_job_find(TALLOC_CTX *mem_ctx, + const char *sharename, + uint32_t jobid) +{ + struct printjob *pjob; + uint32_t tmp; + TDB_DATA ret; + struct tdb_print_db *pdb = get_print_db_byname(sharename); + + DEBUG(10,("print_job_find: looking up job %u for share %s\n", + (unsigned int)jobid, sharename )); + + if (!pdb) { + return NULL; + } + + ret = tdb_fetch(pdb->tdb, print_key(jobid, &tmp)); + release_print_db(pdb); + + if (!ret.dptr) { + DEBUG(10, ("print_job_find: failed to find jobid %u.\n", + jobid)); + return NULL; + } + + pjob = talloc_zero(mem_ctx, struct printjob); + if (pjob == NULL) { + goto err_out; + } + + if (unpack_pjob(mem_ctx, ret.dptr, ret.dsize, pjob) == -1) { + DEBUG(10, ("failed to unpack jobid %u.\n", jobid)); + talloc_free(pjob); + pjob = NULL; + goto err_out; + } + + DEBUG(10,("print_job_find: returning system job %d for jobid %u.\n", + pjob->sysjob, jobid)); + SMB_ASSERT(pjob->jobid == jobid); + +err_out: + SAFE_FREE(ret.dptr); + return pjob; +} + +struct job_traverse_state { + int sysjob; + uint32_t jobid; +}; + +/* find spoolss jobid based on sysjob */ +static int sysjob_to_jobid_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, + TDB_DATA data, void *private_data) +{ + struct printjob *pjob; + struct job_traverse_state *state = + (struct job_traverse_state *)private_data; + + if (!data.dptr || data.dsize == 0) + return 0; + + pjob = (struct printjob *)data.dptr; + if (key.dsize != sizeof(uint32_t)) + return 0; + + if (state->sysjob == pjob->sysjob) { + state->jobid = pjob->jobid; + return 1; + } + + return 0; +} + +uint32_t sysjob_to_jobid_pdb(struct tdb_print_db *pdb, int sysjob) +{ + struct job_traverse_state state; + + state.sysjob = sysjob; + state.jobid = (uint32_t)-1; + + tdb_traverse(pdb->tdb, sysjob_to_jobid_traverse_fn, &state); + + return state.jobid; +} + +/**************************************************************************** + This is a *horribly expensive call as we have to iterate through all the + current printer tdb's. Don't do this often ! JRA. +****************************************************************************/ + +uint32_t sysjob_to_jobid(int unix_jobid) +{ + int services = lp_numservices(); + int snum; + struct job_traverse_state state; + + state.sysjob = unix_jobid; + state.jobid = (uint32_t)-1; + + for (snum = 0; snum < services; snum++) { + struct tdb_print_db *pdb; + if (!lp_printable(snum)) + continue; + pdb = get_print_db_byname(lp_const_servicename(snum)); + if (!pdb) { + continue; + } + tdb_traverse(pdb->tdb, sysjob_to_jobid_traverse_fn, &state); + release_print_db(pdb); + if (state.jobid != (uint32_t)-1) + return state.jobid; + } + return (uint32_t)-1; +} + +/* find sysjob based on spoolss jobid */ +static int jobid_to_sysjob_traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, + TDB_DATA data, void *private_data) +{ + struct printjob *pjob; + struct job_traverse_state *state = + (struct job_traverse_state *)private_data; + + if (!data.dptr || data.dsize == 0) + return 0; + + pjob = (struct printjob *)data.dptr; + if (key.dsize != sizeof(uint32_t)) + return 0; + + if (state->jobid == pjob->jobid) { + state->sysjob = pjob->sysjob; + return 1; + } + + return 0; +} + +int jobid_to_sysjob_pdb(struct tdb_print_db *pdb, uint32_t jobid) +{ + struct job_traverse_state state; + + state.sysjob = -1; + state.jobid = jobid; + + tdb_traverse(pdb->tdb, jobid_to_sysjob_traverse_fn, &state); + + return state.sysjob; +} + +/**************************************************************************** + Send notifications based on what has changed after a pjob_store. +****************************************************************************/ + +static const struct { + uint32_t lpq_status; + uint32_t spoolss_status; +} lpq_to_spoolss_status_map[] = { + { LPQ_QUEUED, JOB_STATUS_QUEUED }, + { LPQ_PAUSED, JOB_STATUS_PAUSED }, + { LPQ_SPOOLING, JOB_STATUS_SPOOLING }, + { LPQ_PRINTING, JOB_STATUS_PRINTING }, + { LPQ_DELETING, JOB_STATUS_DELETING }, + { LPQ_OFFLINE, JOB_STATUS_OFFLINE }, + { LPQ_PAPEROUT, JOB_STATUS_PAPEROUT }, + { LPQ_PRINTED, JOB_STATUS_PRINTED }, + { LPQ_DELETED, JOB_STATUS_DELETED }, + { LPQ_BLOCKED, JOB_STATUS_BLOCKED_DEVQ }, + { LPQ_USER_INTERVENTION, JOB_STATUS_USER_INTERVENTION }, + { (uint32_t)-1, 0 } +}; + +/* Convert a lpq status value stored in printing.tdb into the + appropriate win32 API constant. */ + +static uint32_t map_to_spoolss_status(uint32_t lpq_status) +{ + int i = 0; + + while (lpq_to_spoolss_status_map[i].lpq_status != -1) { + if (lpq_to_spoolss_status_map[i].lpq_status == lpq_status) + return lpq_to_spoolss_status_map[i].spoolss_status; + i++; + } + + return 0; +} + +/*************************************************************************** + Append a jobid to a list +***************************************************************************/ + +static bool add_to_jobs_list( + struct tdb_print_db *pdb, uint32_t jobid, const char *key) +{ + uint8_t store_jobid[sizeof(uint32_t)]; + TDB_DATA data = { + .dptr = store_jobid, .dsize = sizeof(store_jobid) + }; + int ret; + + SIVAL(&store_jobid, 0, jobid); + + DBG_DEBUG("Added jobid %"PRIu32" to %s\n", jobid, key); + + ret = tdb_append(pdb->tdb, string_tdb_data(key), data); + return ret == 0; +} + +/*************************************************************************** + Remove a jobid from the 'jobs changed' list. +***************************************************************************/ + +static bool remove_from_jobs_list( + const char *keystr, const char *sharename, uint32_t jobid) +{ + struct tdb_print_db *pdb = get_print_db_byname(sharename); + TDB_DATA data, key; + size_t job_count, i; + bool ret = False; + bool gotlock = False; + + if (!pdb) { + return False; + } + + ZERO_STRUCT(data); + + key = string_tdb_data(keystr); + + if (tdb_chainlock_with_timeout(pdb->tdb, key, 5) != 0) + goto out; + + gotlock = True; + + data = tdb_fetch(pdb->tdb, key); + + if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) + goto out; + + job_count = data.dsize / 4; + for (i = 0; i < job_count; i++) { + uint32_t ch_jobid; + + ch_jobid = IVAL(data.dptr, i*4); + if (ch_jobid == jobid) { + if (i < job_count -1 ) + memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 ); + data.dsize -= 4; + if (tdb_store(pdb->tdb, key, data, TDB_REPLACE) != 0) + goto out; + break; + } + } + + ret = True; + out: + + if (gotlock) + tdb_chainunlock(pdb->tdb, key); + SAFE_FREE(data.dptr); + release_print_db(pdb); + if (ret) + DBG_DEBUG("removed jobid %"PRIu32"\n", jobid); + else + DBG_DEBUG("Failed to remove jobid %"PRIu32"\n", jobid); + return ret; +} + +static bool remove_from_jobs_changed(const char* sharename, uint32_t jobid) +{ + bool ret = remove_from_jobs_list( + "INFO/jobs_changed", sharename, jobid); + return ret; +} + +static void pjob_store_notify(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char* sharename, uint32_t jobid, + struct printjob *old_data, + struct printjob *new_data, + bool *pchanged) +{ + bool new_job = false; + bool changed = false; + + if (old_data == NULL) { + new_job = true; + } + + /* ACHTUNG! Due to a bug in Samba's spoolss parsing of the + NOTIFY_INFO_DATA buffer, we *have* to send the job submission + time first or else we'll end up with potential alignment + errors. I don't think the systemtime should be spooled as + a string, but this gets us around that error. + --jerry (i'll feel dirty for this) */ + + if (new_job) { + notify_job_submitted(ev, msg_ctx, + sharename, jobid, new_data->starttime); + notify_job_username(ev, msg_ctx, + sharename, jobid, new_data->user); + notify_job_name(ev, msg_ctx, + sharename, jobid, new_data->jobname); + notify_job_status(ev, msg_ctx, + sharename, jobid, map_to_spoolss_status(new_data->status)); + notify_job_total_bytes(ev, msg_ctx, + sharename, jobid, new_data->size); + notify_job_total_pages(ev, msg_ctx, + sharename, jobid, new_data->page_count); + } else { + if (!strequal(old_data->jobname, new_data->jobname)) { + notify_job_name(ev, msg_ctx, sharename, + jobid, new_data->jobname); + changed = true; + } + + if (old_data->status != new_data->status) { + notify_job_status(ev, msg_ctx, + sharename, jobid, + map_to_spoolss_status(new_data->status)); + } + + if (old_data->size != new_data->size) { + notify_job_total_bytes(ev, msg_ctx, + sharename, jobid, new_data->size); + } + + if (old_data->page_count != new_data->page_count) { + notify_job_total_pages(ev, msg_ctx, + sharename, jobid, + new_data->page_count); + } + } + + *pchanged = changed; +} + +/**************************************************************************** + Store a job structure back to the database. +****************************************************************************/ + +static bool pjob_store(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char* sharename, uint32_t jobid, + struct printjob *pjob) +{ + uint32_t tmp; + TDB_DATA old_data, new_data; + bool ret = False; + struct tdb_print_db *pdb = get_print_db_byname(sharename); + uint8_t *buf = NULL; + int len, newlen, buflen; + + + if (!pdb) + return False; + + /* Get old data */ + + old_data = tdb_fetch(pdb->tdb, print_key(jobid, &tmp)); + + /* Doh! Now we have to pack/unpack data since the NT_DEVICEMODE was added */ + + newlen = 0; + + do { + len = 0; + buflen = newlen; + len += tdb_pack(buf+len, buflen-len, "ddddddddddfffff", + (uint32_t)pjob->pid, + (uint32_t)pjob->jobid, + (uint32_t)pjob->sysjob, + (uint32_t)pjob->fd, + (uint32_t)pjob->starttime, + (uint32_t)pjob->status, + (uint32_t)pjob->size, + (uint32_t)pjob->page_count, + (uint32_t)pjob->spooled, + (uint32_t)pjob->smbjob, + pjob->filename, + pjob->jobname, + pjob->user, + pjob->clientmachine, + pjob->queuename); + + len += pack_devicemode(pjob->devmode, buf+len, buflen-len); + + if (buflen != len) { + buf = (uint8_t *)SMB_REALLOC(buf, len); + if (!buf) { + DEBUG(0,("pjob_store: failed to enlarge buffer!\n")); + goto done; + } + newlen = len; + } + } while ( buflen != len ); + + + /* Store new data */ + + new_data.dptr = buf; + new_data.dsize = len; + ret = (tdb_store(pdb->tdb, print_key(jobid, &tmp), new_data, + TDB_REPLACE) == 0); + + /* Send notify updates for what has changed */ + + if (ret) { + bool changed = false; + struct printjob old_pjob; + + if (old_data.dsize) { + TALLOC_CTX *tmp_ctx = talloc_new(ev); + if (tmp_ctx == NULL) + goto done; + + len = unpack_pjob(tmp_ctx, old_data.dptr, + old_data.dsize, &old_pjob); + if (len != -1 ) { + pjob_store_notify(ev, + msg_ctx, + sharename, jobid, &old_pjob, + pjob, + &changed); + if (changed) { + add_to_jobs_list( + pdb, + jobid, + "INFO/jobs_changed"); + } + } + talloc_free(tmp_ctx); + + } else { + /* new job */ + pjob_store_notify(ev, msg_ctx, + sharename, jobid, NULL, pjob, + &changed); + } + } + +done: + release_print_db(pdb); + SAFE_FREE( old_data.dptr ); + SAFE_FREE( buf ); + + return ret; +} + +/**************************************************************************** + Remove a job structure from the database. +****************************************************************************/ + +static void pjob_delete(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char* sharename, uint32_t jobid) +{ + uint32_t tmp; + struct printjob *pjob; + uint32_t job_status = 0; + struct tdb_print_db *pdb; + TALLOC_CTX *tmp_ctx = talloc_new(ev); + if (tmp_ctx == NULL) { + return; + } + + pdb = get_print_db_byname(sharename); + if (!pdb) { + goto err_out; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob) { + DEBUG(5, ("we were asked to delete nonexistent job %u\n", + jobid)); + goto err_release; + } + + /* We must cycle through JOB_STATUS_DELETING and + JOB_STATUS_DELETED for the port monitor to delete the job + properly. */ + + job_status = JOB_STATUS_DELETING|JOB_STATUS_DELETED; + notify_job_status(ev, msg_ctx, sharename, jobid, job_status); + + /* Remove from printing.tdb */ + + tdb_delete(pdb->tdb, print_key(jobid, &tmp)); + remove_from_jobs_added(sharename, jobid); + rap_jobid_delete(sharename, jobid); +err_release: + release_print_db(pdb); +err_out: + talloc_free(tmp_ctx); +} + +/**************************************************************************** + List a unix job in the print database. +****************************************************************************/ + +static void print_unix_job(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, print_queue_struct *q, + uint32_t jobid) +{ + struct printjob pj, *old_pj; + TALLOC_CTX *tmp_ctx = talloc_new(ev); + if (tmp_ctx == NULL) { + return; + } + + if (jobid == (uint32_t)-1) { + jobid = q->sysjob + UNIX_JOB_START; + } + + /* Preserve the timestamp on an existing unix print job */ + + old_pj = print_job_find(tmp_ctx, sharename, jobid); + + ZERO_STRUCT(pj); + + pj.pid = (pid_t)-1; + pj.jobid = jobid; + pj.sysjob = q->sysjob; + pj.fd = -1; + pj.starttime = old_pj ? old_pj->starttime : q->time; + pj.status = q->status; + pj.size = q->size; + pj.spooled = True; + fstrcpy(pj.filename, old_pj ? old_pj->filename : ""); + if (jobid < UNIX_JOB_START) { + pj.smbjob = True; + fstrcpy(pj.jobname, old_pj ? old_pj->jobname : "Remote Downlevel Document"); + } else { + pj.smbjob = False; + fstrcpy(pj.jobname, old_pj ? old_pj->jobname : q->fs_file); + } + fstrcpy(pj.user, old_pj ? old_pj->user : q->fs_user); + fstrcpy(pj.queuename, old_pj ? old_pj->queuename : sharename ); + + pjob_store(ev, msg_ctx, sharename, jobid, &pj); + talloc_free(tmp_ctx); +} + + +struct traverse_struct { + print_queue_struct *queue; + size_t qcount, snum, maxcount, total_jobs; + const char *sharename; + time_t lpq_time; + const char *lprm_command; + struct printif *print_if; + struct tevent_context *ev; + struct messaging_context *msg_ctx; + TALLOC_CTX *mem_ctx; +}; + +/**************************************************************************** + Utility fn to delete any jobs that are no longer active. +****************************************************************************/ + +static int traverse_fn_delete(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state) +{ + struct traverse_struct *ts = (struct traverse_struct *)state; + struct printjob pjob; + uint32_t jobid; + size_t i = 0; + + if ( key.dsize != sizeof(jobid) ) + return 0; + + if (unpack_pjob(ts->mem_ctx, data.dptr, data.dsize, &pjob) == -1) + return 0; + talloc_free(pjob.devmode); + jobid = pjob.jobid; + + if (!pjob.smbjob) { + /* remove a unix job if it isn't in the system queue any more */ + for (i=0;iqcount;i++) { + if (ts->queue[i].sysjob == pjob.sysjob) { + break; + } + } + if (i == ts->qcount) { + DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !smbjob\n", + (unsigned int)jobid )); + pjob_delete(ts->ev, ts->msg_ctx, + ts->sharename, jobid); + return 0; + } + + /* need to continue the the bottom of the function to + save the correct attributes */ + } + + /* maybe it hasn't been spooled yet */ + if (!pjob.spooled) { + /* if a job is not spooled and the process doesn't + exist then kill it. This cleans up after smbd + deaths */ + if (!process_exists_by_pid(pjob.pid)) { + DEBUG(10,("traverse_fn_delete: pjob %u deleted due to !process_exists (%u)\n", + (unsigned int)jobid, (unsigned int)pjob.pid )); + pjob_delete(ts->ev, ts->msg_ctx, + ts->sharename, jobid); + } else + ts->total_jobs++; + return 0; + } + + /* this check only makes sense for jobs submitted from Windows clients */ + + if (pjob.smbjob) { + for (i=0;iqcount;i++) { + if ( pjob.status == LPQ_DELETED ) + continue; + + if (ts->queue[i].sysjob == pjob.sysjob) { + + /* try to clean up any jobs that need to be deleted */ + + if ( pjob.status == LPQ_DELETING ) { + int result; + + result = (*(ts->print_if->job_delete))( + ts->sharename, ts->lprm_command, &pjob ); + + if ( result != 0 ) { + /* if we can't delete, then reset the job status */ + pjob.status = LPQ_QUEUED; + pjob_store(ts->ev, ts->msg_ctx, + ts->sharename, jobid, &pjob); + } + else { + /* if we deleted the job, the remove the tdb record */ + pjob_delete(ts->ev, + ts->msg_ctx, + ts->sharename, jobid); + pjob.status = LPQ_DELETED; + } + + } + + break; + } + } + } + + /* The job isn't in the system queue - we have to assume it has + completed, so delete the database entry. */ + + if (i == ts->qcount) { + + /* A race can occur between the time a job is spooled and + when it appears in the lpq output. This happens when + the job is added to printing.tdb when another smbd + running print_queue_update() has completed a lpq and + is currently traversing the printing tdb and deleting jobs. + Don't delete the job if it was submitted after the lpq_time. */ + + if (pjob.starttime < ts->lpq_time) { + DEBUG(10,("traverse_fn_delete: pjob %u deleted due to pjob.starttime (%u) < ts->lpq_time (%u)\n", + (unsigned int)jobid, + (unsigned int)pjob.starttime, + (unsigned int)ts->lpq_time )); + pjob_delete(ts->ev, ts->msg_ctx, + ts->sharename, jobid); + } else + ts->total_jobs++; + return 0; + } + + /* Save the pjob attributes we will store. */ + ts->queue[i].sysjob = pjob.sysjob; + ts->queue[i].size = pjob.size; + ts->queue[i].page_count = pjob.page_count; + ts->queue[i].status = pjob.status; + ts->queue[i].priority = 1; + ts->queue[i].time = pjob.starttime; + fstrcpy(ts->queue[i].fs_user, pjob.user); + fstrcpy(ts->queue[i].fs_file, pjob.jobname); + + ts->total_jobs++; + + return 0; +} + +/**************************************************************************** + Check if the print queue has been updated recently enough. +****************************************************************************/ + +static void print_cache_flush(const char *sharename) +{ + fstring key; + struct tdb_print_db *pdb = get_print_db_byname(sharename); + + if (!pdb) + return; + slprintf(key, sizeof(key)-1, "CACHE/%s", sharename); + tdb_store_int32(pdb->tdb, key, -1); + release_print_db(pdb); +} + +/**************************************************************************** + Check if someone already thinks they are doing the update. +****************************************************************************/ + +static pid_t get_updating_pid(const char *sharename) +{ + fstring keystr; + TDB_DATA data, key; + pid_t updating_pid; + struct tdb_print_db *pdb = get_print_db_byname(sharename); + + if (!pdb) + return (pid_t)-1; + slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename); + key = string_tdb_data(keystr); + + data = tdb_fetch(pdb->tdb, key); + release_print_db(pdb); + if (!data.dptr || data.dsize != sizeof(pid_t)) { + SAFE_FREE(data.dptr); + return (pid_t)-1; + } + + updating_pid = IVAL(data.dptr, 0); + SAFE_FREE(data.dptr); + + if (process_exists_by_pid(updating_pid)) + return updating_pid; + + return (pid_t)-1; +} + +/**************************************************************************** + Set the fact that we're doing the update, or have finished doing the update + in the tdb. +****************************************************************************/ + +static void set_updating_pid(const fstring sharename, bool updating) +{ + fstring keystr; + TDB_DATA key; + TDB_DATA data; + pid_t updating_pid = getpid(); + uint8_t buffer[4]; + + struct tdb_print_db *pdb = get_print_db_byname(sharename); + + if (!pdb) + return; + + slprintf(keystr, sizeof(keystr)-1, "UPDATING/%s", sharename); + key = string_tdb_data(keystr); + + DEBUG(5, ("set_updating_pid: %supdating lpq cache for print share %s\n", + updating ? "" : "not ", + sharename )); + + if ( !updating ) { + tdb_delete(pdb->tdb, key); + release_print_db(pdb); + return; + } + + SIVAL( buffer, 0, updating_pid); + data.dptr = buffer; + data.dsize = 4; /* we always assume this is a 4 byte value */ + + tdb_store(pdb->tdb, key, data, TDB_REPLACE); + release_print_db(pdb); +} + +/**************************************************************************** + Sort print jobs by submittal time. +****************************************************************************/ + +static int printjob_comp(print_queue_struct *j1, print_queue_struct *j2) +{ + /* Silly cases */ + + if (!j1 && !j2) + return 0; + if (!j1) + return -1; + if (!j2) + return 1; + + /* Sort on job start time */ + + if (j1->time == j2->time) + return 0; + return (j1->time > j2->time) ? 1 : -1; +} + +/**************************************************************************** + Store the sorted queue representation for later portmon retrieval. + Skip deleted jobs +****************************************************************************/ + +static void store_queue_struct(struct tdb_print_db *pdb, struct traverse_struct *pts) +{ + TDB_DATA data; + int max_reported_jobs = lp_max_reported_print_jobs(pts->snum); + print_queue_struct *queue = pts->queue; + size_t len; + size_t i; + unsigned int qcount; + + if (max_reported_jobs && (max_reported_jobs < pts->qcount)) + pts->qcount = max_reported_jobs; + qcount = 0; + + /* Work out the size. */ + data.dsize = 0; + data.dsize += tdb_pack(NULL, 0, "d", qcount); + + for (i = 0; i < pts->qcount; i++) { + if ( queue[i].status == LPQ_DELETED ) + continue; + + qcount++; + data.dsize += tdb_pack(NULL, 0, "ddddddff", + (uint32_t)queue[i].sysjob, + (uint32_t)queue[i].size, + (uint32_t)queue[i].page_count, + (uint32_t)queue[i].status, + (uint32_t)queue[i].priority, + (uint32_t)queue[i].time, + queue[i].fs_user, + queue[i].fs_file); + } + + if ((data.dptr = (uint8_t *)SMB_MALLOC(data.dsize)) == NULL) + return; + + len = 0; + len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount); + for (i = 0; i < pts->qcount; i++) { + if ( queue[i].status == LPQ_DELETED ) + continue; + + len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff", + (uint32_t)queue[i].sysjob, + (uint32_t)queue[i].size, + (uint32_t)queue[i].page_count, + (uint32_t)queue[i].status, + (uint32_t)queue[i].priority, + (uint32_t)queue[i].time, + queue[i].fs_user, + queue[i].fs_file); + } + + tdb_store(pdb->tdb, string_tdb_data("INFO/linear_queue_array"), data, + TDB_REPLACE); + SAFE_FREE(data.dptr); + return; +} + +static TDB_DATA get_jobs_added_data(struct tdb_print_db *pdb) +{ + TDB_DATA data; + + ZERO_STRUCT(data); + + data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_added")); + if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) { + SAFE_FREE(data.dptr); + ZERO_STRUCT(data); + } + + return data; +} + +static void check_job_added(const char *sharename, TDB_DATA data, uint32_t jobid) +{ + unsigned int i; + unsigned int job_count = data.dsize / 4; + + for (i = 0; i < job_count; i++) { + uint32_t ch_jobid; + + ch_jobid = IVAL(data.dptr, i*4); + if (ch_jobid == jobid) + remove_from_jobs_added(sharename, jobid); + } +} + +/**************************************************************************** + Check if the print queue has been updated recently enough. +****************************************************************************/ + +static bool print_cache_expired(const char *sharename, bool check_pending) +{ + fstring key; + time_t last_qscan_time, time_now = time(NULL); + struct tdb_print_db *pdb = get_print_db_byname(sharename); + bool result = False; + + if (!pdb) + return False; + + snprintf(key, sizeof(key), "CACHE/%s", sharename); + last_qscan_time = (time_t)tdb_fetch_int32(pdb->tdb, key); + + /* + * Invalidate the queue for 3 reasons. + * (1). last queue scan time == -1. + * (2). Current time - last queue scan time > allowed cache time. + * (3). last queue scan time > current time + MAX_CACHE_VALID_TIME (1 hour by default). + * This last test picks up machines for which the clock has been moved + * forward, an lpq scan done and then the clock moved back. Otherwise + * that last lpq scan would stay around for a loooong loooong time... :-). JRA. + */ + + if (last_qscan_time == ((time_t)-1) + || (time_now - last_qscan_time) >= lp_lpq_cache_time() + || last_qscan_time > (time_now + MAX_CACHE_VALID_TIME)) + { + uint32_t u; + time_t msg_pending_time; + + DEBUG(4, ("print_cache_expired: cache expired for queue %s " + "(last_qscan_time = %d, time now = %d, qcachetime = %d)\n", + sharename, (int)last_qscan_time, (int)time_now, + (int)lp_lpq_cache_time() )); + + /* check if another smbd has already sent a message to update the + queue. Give the pending message one minute to clear and + then send another message anyways. Make sure to check for + clocks that have been run forward and then back again. */ + + snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename); + + if ( check_pending + && tdb_fetch_uint32( pdb->tdb, key, &u ) + && (msg_pending_time=u) > 0 + && msg_pending_time <= time_now + && (time_now - msg_pending_time) < 60 ) + { + DEBUG(4,("print_cache_expired: message already pending for %s. Accepting cache\n", + sharename)); + goto done; + } + + result = True; + } + +done: + release_print_db(pdb); + return result; +} + +/**************************************************************************** + main work for updating the lpq cache for a printer queue +****************************************************************************/ + +static void print_queue_update_internal(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, + struct printif *current_printif, + char *lpq_command, char *lprm_command) +{ + size_t i, qcount; + print_queue_struct *queue = NULL; + print_status_struct status; + print_status_struct old_status; + struct printjob *pjob; + struct traverse_struct tstruct; + TDB_DATA data, key; + TDB_DATA jcdata; + fstring keystr, cachestr; + struct tdb_print_db *pdb = get_print_db_byname(sharename); + TALLOC_CTX *tmp_ctx = talloc_new(ev); + + if ((pdb == NULL) || (tmp_ctx == NULL)) { + return; + } + + DEBUG(5,("print_queue_update_internal: printer = %s, type = %d, lpq command = [%s]\n", + sharename, current_printif->type, lpq_command)); + + /* + * Update the cache time FIRST ! Stops others even + * attempting to get the lock and doing this + * if the lpq takes a long time. + */ + + slprintf(cachestr, sizeof(cachestr)-1, "CACHE/%s", sharename); + tdb_store_int32(pdb->tdb, cachestr, (int)time(NULL)); + + /* get the current queue using the appropriate interface */ + ZERO_STRUCT(status); + + qcount = (*(current_printif->queue_get))(sharename, + current_printif->type, + lpq_command, &queue, &status); + + DBG_NOTICE("%zu job%s in queue for %s\n", + qcount, + (qcount != 1) ? "s" : "", + sharename); + + /* Sort the queue by submission time otherwise they are displayed + in hash order. */ + + TYPESAFE_QSORT(queue, qcount, printjob_comp); + + /* + any job in the internal database that is marked as spooled + and doesn't exist in the system queue is considered finished + and removed from the database + + any job in the system database but not in the internal database + is added as a unix job + + fill in any system job numbers as we go + */ + jcdata = get_jobs_added_data(pdb); + + for (i=0; istatus != LPQ_DELETING ) + pjob->status = queue[i].status; + + pjob_store(ev, msg_ctx, sharename, jobid, pjob); + + check_job_added(sharename, jcdata, jobid); + } + + SAFE_FREE(jcdata.dptr); + + /* now delete any queued entries that don't appear in the + system queue */ + tstruct.queue = queue; + tstruct.qcount = qcount; + tstruct.snum = -1; + tstruct.total_jobs = 0; + tstruct.lpq_time = time(NULL); + tstruct.sharename = sharename; + tstruct.lprm_command = lprm_command; + tstruct.print_if = current_printif; + tstruct.ev = ev; + tstruct.msg_ctx = msg_ctx; + tstruct.mem_ctx = tmp_ctx; + + tdb_traverse(pdb->tdb, traverse_fn_delete, (void *)&tstruct); + + /* Store the linearised queue, max jobs only. */ + store_queue_struct(pdb, &tstruct); + + SAFE_FREE(tstruct.queue); + talloc_free(tmp_ctx); + + DBG_DEBUG("printer %s INFO, total_jobs = %zu\n", + sharename, + tstruct.total_jobs); + + tdb_store_int32(pdb->tdb, "INFO/total_jobs", tstruct.total_jobs); + + get_queue_status(sharename, &old_status); + if (old_status.qcount != qcount) { + DBG_DEBUG("Queue status change %zu jobs -> %zu jobs " + "for printer %s\n", + old_status.qcount, + qcount, + sharename); + } + + /* store the new queue status structure */ + slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename); + key = string_tdb_data(keystr); + + status.qcount = qcount; + data.dptr = (uint8_t *)&status; + data.dsize = sizeof(status); + tdb_store(pdb->tdb, key, data, TDB_REPLACE); + + /* + * Update the cache time again. We want to do this call + * as little as possible... + */ + + slprintf(keystr, sizeof(keystr)-1, "CACHE/%s", sharename); + tdb_store_int32(pdb->tdb, keystr, (int32_t)time(NULL)); + + /* clear the msg pending record for this queue */ + + snprintf(keystr, sizeof(keystr), "MSG_PENDING/%s", sharename); + + if ( !tdb_store_uint32( pdb->tdb, keystr, 0 ) ) { + /* log a message but continue on */ + + DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n", + sharename)); + } + + release_print_db( pdb ); + + return; +} + +/**************************************************************************** + Update the internal database from the system print queue for a queue. + obtain a lock on the print queue before proceeding (needed when multiple + smbd processes maytry to update the lpq cache concurrently). +****************************************************************************/ + +static void print_queue_update_with_lock( struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, + struct printif *current_printif, + char *lpq_command, char *lprm_command ) +{ + fstring keystr; + struct tdb_print_db *pdb; + + DEBUG(5,("print_queue_update_with_lock: printer share = %s\n", sharename)); + pdb = get_print_db_byname(sharename); + if (!pdb) + return; + + if ( !print_cache_expired(sharename, False) ) { + DEBUG(5,("print_queue_update_with_lock: print cache for %s is still ok\n", sharename)); + release_print_db(pdb); + return; + } + + /* + * Check to see if someone else is doing this update. + * This is essentially a mutex on the update. + */ + + if (get_updating_pid(sharename) != -1) { + release_print_db(pdb); + return; + } + + /* Lock the queue for the database update */ + + slprintf(keystr, sizeof(keystr) - 1, "LOCK/%s", sharename); + /* Only wait 10 seconds for this. */ + if (tdb_lock_bystring_with_timeout(pdb->tdb, keystr, 10) != 0) { + DEBUG(0,("print_queue_update_with_lock: Failed to lock printer %s database\n", sharename)); + release_print_db(pdb); + return; + } + + /* + * Ensure that no one else got in here. + * If the updating pid is still -1 then we are + * the winner. + */ + + if (get_updating_pid(sharename) != -1) { + /* + * Someone else is doing the update, exit. + */ + tdb_unlock_bystring(pdb->tdb, keystr); + release_print_db(pdb); + return; + } + + /* + * We're going to do the update ourselves. + */ + + /* Tell others we're doing the update. */ + set_updating_pid(sharename, True); + + /* + * Allow others to enter and notice we're doing + * the update. + */ + + tdb_unlock_bystring(pdb->tdb, keystr); + + /* do the main work now */ + + print_queue_update_internal(ev, msg_ctx, + sharename, current_printif, + lpq_command, lprm_command); + + /* Delete our pid from the db. */ + set_updating_pid(sharename, False); + release_print_db(pdb); +} + +/**************************************************************************** +this is the receive function of the background lpq updater +****************************************************************************/ +void print_queue_receive(struct messaging_context *msg, + void *private_data, + uint32_t msg_type, + struct server_id server_id, + DATA_BLOB *data) +{ + fstring sharename; + char *lpqcommand = NULL, *lprmcommand = NULL; + int printing_type; + size_t len; + + len = tdb_unpack( (uint8_t *)data->data, data->length, "fdPP", + sharename, + &printing_type, + &lpqcommand, + &lprmcommand ); + + if ( len == -1 ) { + SAFE_FREE(lpqcommand); + SAFE_FREE(lprmcommand); + DEBUG(0,("print_queue_receive: Got invalid print queue update message\n")); + return; + } + + print_queue_update_with_lock(global_event_context(), msg, sharename, + get_printer_fns_from_type((enum printing_types)printing_type), + lpqcommand, lprmcommand ); + + SAFE_FREE(lpqcommand); + SAFE_FREE(lprmcommand); + return; +} + +/**************************************************************************** +update the internal database from the system print queue for a queue +****************************************************************************/ + +static void print_queue_update(struct messaging_context *msg_ctx, + int snum, bool force) +{ + char key[268]; + fstring sharename; + char *lpqcommand = NULL; + char *lprmcommand = NULL; + uint8_t *buffer = NULL; + size_t len = 0; + size_t newlen; + struct tdb_print_db *pdb; + int type; + struct printif *current_printif; + TALLOC_CTX *ctx = talloc_tos(); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + fstrcpy( sharename, lp_const_servicename(snum)); + + /* don't strip out characters like '$' from the printername */ + + lpqcommand = talloc_string_sub2(ctx, + lp_lpq_command(snum), + "%p", + lp_printername(talloc_tos(), lp_sub, snum), + false, false, false); + if (!lpqcommand) { + return; + } + lpqcommand = talloc_sub_full(ctx, + lp_servicename(talloc_tos(), lp_sub, snum), + current_user_info.unix_name, + "", + get_current_gid(NULL), + get_current_username(), + get_current_user_info_domain(), + lpqcommand); + if (!lpqcommand) { + return; + } + + lprmcommand = talloc_string_sub2(ctx, + lp_lprm_command(snum), + "%p", + lp_printername(talloc_tos(), lp_sub, snum), + false, false, false); + if (!lprmcommand) { + return; + } + lprmcommand = talloc_sub_full(ctx, + lp_servicename(talloc_tos(), lp_sub, snum), + current_user_info.unix_name, + "", + get_current_gid(NULL), + get_current_username(), + get_current_user_info_domain(), + lprmcommand); + if (!lprmcommand) { + return; + } + + /* + * Make sure that the background queue process exists. + * Otherwise just do the update ourselves + */ + + if ( force || background_lpq_updater_pid == -1 ) { + DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename)); + current_printif = get_printer_fns( snum ); + print_queue_update_with_lock(global_event_context(), msg_ctx, + sharename, current_printif, + lpqcommand, lprmcommand); + + return; + } + + type = lp_printing(snum); + + /* get the length */ + + len = tdb_pack( NULL, 0, "fdPP", + sharename, + type, + lpqcommand, + lprmcommand ); + + buffer = SMB_XMALLOC_ARRAY( uint8_t, len ); + + /* now pack the buffer */ + newlen = tdb_pack( buffer, len, "fdPP", + sharename, + type, + lpqcommand, + lprmcommand ); + + SMB_ASSERT( newlen == len ); + + DEBUG(10,("print_queue_update: Sending message -> printer = %s, " + "type = %d, lpq command = [%s] lprm command = [%s]\n", + sharename, type, lpqcommand, lprmcommand )); + + /* here we set a msg pending record for other smbd processes + to throttle the number of duplicate print_queue_update msgs + sent. */ + + pdb = get_print_db_byname(sharename); + if (!pdb) { + SAFE_FREE(buffer); + return; + } + + snprintf(key, sizeof(key), "MSG_PENDING/%s", sharename); + + if ( !tdb_store_uint32( pdb->tdb, key, time(NULL) ) ) { + /* log a message but continue on */ + + DEBUG(0,("print_queue_update: failed to store MSG_PENDING flag for [%s]!\n", + sharename)); + } + + release_print_db( pdb ); + + /* finally send the message */ + + send_to_bgqd(msg_ctx, MSG_PRINTER_UPDATE, (uint8_t *)buffer, len); + + SAFE_FREE( buffer ); + + return; +} + +/**************************************************************************** + Create/Update an entry in the print tdb that will allow us to send notify + updates only to interested smbd's. +****************************************************************************/ + +bool print_notify_register_pid(int snum) +{ + TDB_DATA data; + struct tdb_print_db *pdb = NULL; + TDB_CONTEXT *tdb = NULL; + const char *printername; + uint32_t mypid = (uint32_t)getpid(); + bool ret = False; + size_t i; + + /* if (snum == -1), then the change notify request was + on a print server handle and we need to register on + all print queues */ + + if (snum == -1) + { + int num_services = lp_numservices(); + int idx; + + for ( idx=0; idxtdb; + } + + if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) { + DEBUG(0,("print_notify_register_pid: Failed to lock printer %s\n", + printername)); + if (pdb) + release_print_db(pdb); + return False; + } + + data = get_printer_notify_pid_list( tdb, printername, True ); + + /* Add ourselves and increase the refcount. */ + + for (i = 0; i < data.dsize; i += 8) { + if (IVAL(data.dptr,i) == mypid) { + uint32_t new_refcount = IVAL(data.dptr, i+4) + 1; + SIVAL(data.dptr, i+4, new_refcount); + break; + } + } + + if (i == data.dsize) { + /* We weren't in the list. Realloc. */ + data.dptr = (uint8_t *)SMB_REALLOC(data.dptr, data.dsize + 8); + if (!data.dptr) { + DEBUG(0,("print_notify_register_pid: Relloc fail for printer %s\n", + printername)); + goto done; + } + data.dsize += 8; + SIVAL(data.dptr,data.dsize - 8,mypid); + SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */ + } + + /* Store back the record. */ + if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) != 0) { + DEBUG(0,("print_notify_register_pid: Failed to update pid \ +list for printer %s\n", printername)); + goto done; + } + + ret = True; + + done: + + tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY); + if (pdb) + release_print_db(pdb); + SAFE_FREE(data.dptr); + return ret; +} + +/**************************************************************************** + Update an entry in the print tdb that will allow us to send notify + updates only to interested smbd's. +****************************************************************************/ + +bool print_notify_deregister_pid(int snum) +{ + TDB_DATA data; + struct tdb_print_db *pdb = NULL; + TDB_CONTEXT *tdb = NULL; + const char *printername; + uint32_t mypid = (uint32_t)getpid(); + size_t i; + bool ret = False; + + /* if ( snum == -1 ), we are deregister a print server handle + which means to deregister on all print queues */ + + if (snum == -1) + { + int num_services = lp_numservices(); + int idx; + + for ( idx=0; idxtdb; + } + + if (tdb_lock_bystring_with_timeout(tdb, NOTIFY_PID_LIST_KEY, 10) != 0) { + DEBUG(0,("print_notify_register_pid: Failed to lock \ +printer %s database\n", printername)); + if (pdb) + release_print_db(pdb); + return False; + } + + data = get_printer_notify_pid_list( tdb, printername, True ); + + /* Reduce refcount. Remove ourselves if zero. */ + + for (i = 0; i < data.dsize; ) { + if (IVAL(data.dptr,i) == mypid) { + uint32_t refcount = IVAL(data.dptr, i+4); + + refcount--; + + if (refcount == 0) { + if (data.dsize - i > 8) + memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8); + data.dsize -= 8; + continue; + } + SIVAL(data.dptr, i+4, refcount); + } + + i += 8; + } + + if (data.dsize == 0) + SAFE_FREE(data.dptr); + + /* Store back the record. */ + if (tdb_store_bystring(tdb, NOTIFY_PID_LIST_KEY, data, TDB_REPLACE) != 0) { + DEBUG(0,("print_notify_register_pid: Failed to update pid \ +list for printer %s\n", printername)); + goto done; + } + + ret = True; + + done: + + tdb_unlock_bystring(tdb, NOTIFY_PID_LIST_KEY); + if (pdb) + release_print_db(pdb); + SAFE_FREE(data.dptr); + return ret; +} + +/**************************************************************************** + Check if a jobid is valid. It is valid if it exists in the database. +****************************************************************************/ + +bool print_job_exists(const char* sharename, uint32_t jobid) +{ + struct tdb_print_db *pdb = get_print_db_byname(sharename); + bool ret; + uint32_t tmp; + + if (!pdb) + return False; + ret = tdb_exists(pdb->tdb, print_key(jobid, &tmp)); + release_print_db(pdb); + return ret; +} + +/**************************************************************************** + Return the device mode assigned to a specific print job. + Only valid for the process doing the spooling and when the job + has not been spooled. +****************************************************************************/ + +struct spoolss_DeviceMode *print_job_devmode(TALLOC_CTX *mem_ctx, + const char *sharename, + uint32_t jobid) +{ + struct printjob *pjob = print_job_find(mem_ctx, sharename, jobid); + if (pjob == NULL) { + return NULL; + } + + return pjob->devmode; +} + +/**************************************************************************** + Set the name of a job. Only possible for owner. +****************************************************************************/ + +bool print_job_set_name(struct tevent_context *ev, + struct messaging_context *msg_ctx, + const char *sharename, uint32_t jobid, const char *name) +{ + struct printjob *pjob; + bool ret; + TALLOC_CTX *tmp_ctx = talloc_new(ev); + if (tmp_ctx == NULL) { + return false; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob || pjob->pid != getpid()) { + ret = false; + goto err_out; + } + + fstrcpy(pjob->jobname, name); + ret = pjob_store(ev, msg_ctx, sharename, jobid, pjob); +err_out: + talloc_free(tmp_ctx); + return ret; +} + +/**************************************************************************** + Get the name of a job. Only possible for owner. +****************************************************************************/ + +bool print_job_get_name(TALLOC_CTX *mem_ctx, const char *sharename, uint32_t jobid, char **name) +{ + struct printjob *pjob; + + pjob = print_job_find(mem_ctx, sharename, jobid); + if (!pjob || pjob->pid != getpid()) { + return false; + } + + *name = pjob->jobname; + return true; +} + + +/*************************************************************************** + Remove a jobid from the 'jobs added' list. +***************************************************************************/ + +static bool remove_from_jobs_added(const char* sharename, uint32_t jobid) +{ + bool ret = remove_from_jobs_list("INFO/jobs_added", sharename, jobid); + return ret; +} + +/**************************************************************************** + Delete a print job - don't update queue. +****************************************************************************/ + +static bool print_job_delete1(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, uint32_t jobid) +{ + const char* sharename = lp_const_servicename(snum); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + struct printjob *pjob; + int result = 0; + struct printif *current_printif = get_printer_fns( snum ); + bool ret; + TALLOC_CTX *tmp_ctx = talloc_new(ev); + if (tmp_ctx == NULL) { + return false; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob) { + ret = false; + goto err_out; + } + + /* + * If already deleting just return. + */ + + if (pjob->status == LPQ_DELETING) { + ret = true; + goto err_out; + } + + /* Hrm - we need to be able to cope with deleting a job before it + has reached the spooler. Just mark it as LPQ_DELETING and + let the print_queue_update() code remove the record */ + + + if (pjob->sysjob == -1) { + DEBUG(5, ("attempt to delete job %u not seen by lpr\n", (unsigned int)jobid)); + } + + /* Set the tdb entry to be deleting. */ + + pjob->status = LPQ_DELETING; + pjob_store(ev, msg_ctx, sharename, jobid, pjob); + + if (pjob->spooled && pjob->sysjob != -1) + { + result = (*(current_printif->job_delete))( + lp_printername(talloc_tos(), lp_sub, snum), + lp_lprm_command(snum), + pjob); + + /* Delete the tdb entry if the delete succeeded or the job hasn't + been spooled. */ + + if (result == 0) { + struct tdb_print_db *pdb = get_print_db_byname(sharename); + int njobs = 1; + + if (!pdb) { + ret = false; + goto err_out; + } + pjob_delete(ev, msg_ctx, sharename, jobid); + /* Ensure we keep a rough count of the number of total jobs... */ + tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, -1); + release_print_db(pdb); + } + } + + remove_from_jobs_added( sharename, jobid ); + + ret = (result == 0); +err_out: + talloc_free(tmp_ctx); + return ret; +} + +/**************************************************************************** + Return true if the current user owns the print job. +****************************************************************************/ + +static bool is_owner(const struct auth_session_info *server_info, + const char *servicename, + uint32_t jobid) +{ + struct printjob *pjob; + bool ret; + TALLOC_CTX *tmp_ctx = talloc_new(server_info); + if (tmp_ctx == NULL) { + return false; + } + + pjob = print_job_find(tmp_ctx, servicename, jobid); + if (!pjob || !server_info) { + ret = false; + goto err_out; + } + + ret = strequal(pjob->user, server_info->unix_info->sanitized_username); +err_out: + talloc_free(tmp_ctx); + return ret; +} + +/**************************************************************************** + Delete a print job. +****************************************************************************/ + +WERROR print_job_delete(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, + int snum, uint32_t jobid) +{ + const char* sharename = lp_const_servicename(snum); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + struct printjob *pjob; + bool owner; + WERROR werr; + TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx); + if (tmp_ctx == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + + owner = is_owner(server_info, lp_const_servicename(snum), jobid); + + /* Check access against security descriptor or whether the user + owns their job. */ + + if (!owner && + !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum, + JOB_ACCESS_ADMINISTER))) { + DEBUG(0, ("print job delete denied. " + "User name: %s, Printer name: %s.\n", + uidtoname(server_info->unix_token->uid), + lp_printername(tmp_ctx, lp_sub, snum))); + + werr = WERR_ACCESS_DENIED; + goto err_out; + } + + /* + * get the spooled filename of the print job + * if this works, then the file has not been spooled + * to the underlying print system. Just delete the + * spool file & return. + */ + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob || pjob->spooled || pjob->pid != getpid()) { + DEBUG(10, ("Skipping spool file removal for job %u\n", jobid)); + } else { + DEBUG(10, ("Removing spool file [%s]\n", pjob->filename)); + if (unlink(pjob->filename) == -1) { + werr = map_werror_from_unix(errno); + goto err_out; + } + } + + if (!print_job_delete1(global_event_context(), msg_ctx, snum, jobid)) { + werr = WERR_ACCESS_DENIED; + goto err_out; + } + + /* force update the database and say the delete failed if the + job still exists */ + + print_queue_update(msg_ctx, snum, True); + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (pjob && (pjob->status != LPQ_DELETING)) { + werr = WERR_ACCESS_DENIED; + goto err_out; + } + werr = WERR_PRINTER_HAS_JOBS_QUEUED; + +err_out: + talloc_free(tmp_ctx); + return werr; +} + +/**************************************************************************** + Pause a job. +****************************************************************************/ + +WERROR print_job_pause(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, + int snum, uint32_t jobid) +{ + const char* sharename = lp_const_servicename(snum); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + struct printjob *pjob; + int ret = -1; + struct printif *current_printif = get_printer_fns( snum ); + WERROR werr; + TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx); + if (tmp_ctx == NULL) { + return WERR_NOT_ENOUGH_MEMORY; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob || !server_info) { + DEBUG(10, ("print_job_pause: no pjob or user for jobid %u\n", + (unsigned int)jobid )); + werr = WERR_INVALID_PARAMETER; + goto err_out; + } + + if (!pjob->spooled || pjob->sysjob == -1) { + DEBUG(10, ("print_job_pause: not spooled or bad sysjob = %d for jobid %u\n", + (int)pjob->sysjob, (unsigned int)jobid )); + werr = WERR_INVALID_PARAMETER; + goto err_out; + } + + if (!is_owner(server_info, lp_const_servicename(snum), jobid) && + !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum, + JOB_ACCESS_ADMINISTER))) { + DEBUG(0, ("print job pause denied. " + "User name: %s, Printer name: %s.\n", + uidtoname(server_info->unix_token->uid), + lp_printername(tmp_ctx, lp_sub, snum))); + + werr = WERR_ACCESS_DENIED; + goto err_out; + } + + /* need to pause the spooled entry */ + ret = (*(current_printif->job_pause))(snum, pjob); + + if (ret != 0) { + werr = WERR_INVALID_PARAMETER; + goto err_out; + } + + /* force update the database */ + print_cache_flush(lp_const_servicename(snum)); + + /* Send a printer notify message */ + + notify_job_status(global_event_context(), msg_ctx, sharename, jobid, + JOB_STATUS_PAUSED); + + /* how do we tell if this succeeded? */ + werr = WERR_OK; +err_out: + talloc_free(tmp_ctx); + return werr; +} + +/**************************************************************************** + Resume a job. +****************************************************************************/ + +WERROR print_job_resume(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, + int snum, uint32_t jobid) +{ + const char *sharename = lp_const_servicename(snum); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + struct printjob *pjob; + int ret; + struct printif *current_printif = get_printer_fns( snum ); + WERROR werr; + TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx); + if (tmp_ctx == NULL) + return WERR_NOT_ENOUGH_MEMORY; + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob || !server_info) { + DEBUG(10, ("print_job_resume: no pjob or user for jobid %u\n", + (unsigned int)jobid )); + werr = WERR_INVALID_PARAMETER; + goto err_out; + } + + if (!pjob->spooled || pjob->sysjob == -1) { + DEBUG(10, ("print_job_resume: not spooled or bad sysjob = %d for jobid %u\n", + (int)pjob->sysjob, (unsigned int)jobid )); + werr = WERR_INVALID_PARAMETER; + goto err_out; + } + + if (!is_owner(server_info, lp_const_servicename(snum), jobid) && + !W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum, + JOB_ACCESS_ADMINISTER))) { + DEBUG(0, ("print job resume denied. " + "User name: %s, Printer name: %s.\n", + uidtoname(server_info->unix_token->uid), + lp_printername(tmp_ctx, lp_sub, snum))); + + werr = WERR_ACCESS_DENIED; + goto err_out; + } + + ret = (*(current_printif->job_resume))(snum, pjob); + + if (ret != 0) { + werr = WERR_INVALID_PARAMETER; + goto err_out; + } + + /* force update the database */ + print_cache_flush(lp_const_servicename(snum)); + + /* Send a printer notify message */ + + notify_job_status(global_event_context(), msg_ctx, sharename, jobid, + JOB_STATUS_QUEUED); + + werr = WERR_OK; +err_out: + talloc_free(tmp_ctx); + return werr; +} + +/**************************************************************************** + Write to a print file. +****************************************************************************/ + +ssize_t print_job_write(struct tevent_context *ev, + struct messaging_context *msg_ctx, + int snum, uint32_t jobid, const char *buf, size_t size) +{ + const char* sharename = lp_const_servicename(snum); + ssize_t return_code; + struct printjob *pjob; + TALLOC_CTX *tmp_ctx = talloc_new(ev); + if (tmp_ctx == NULL) { + return -1; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob) { + return_code = -1; + goto err_out; + } + + /* don't allow another process to get this info - it is meaningless */ + if (pjob->pid != getpid()) { + return_code = -1; + goto err_out; + } + + /* if SMBD is spooling this can't be allowed */ + if (pjob->status == PJOB_SMBD_SPOOLING) { + return_code = -1; + goto err_out; + } + + return_code = write_data(pjob->fd, buf, size); + if (return_code > 0) { + pjob->size += size; + pjob_store(ev, msg_ctx, sharename, jobid, pjob); + } +err_out: + talloc_free(tmp_ctx); + return return_code; +} + +/**************************************************************************** + Get the queue status - do not update if db is out of date. +****************************************************************************/ + +static int get_queue_status(const char* sharename, print_status_struct *status) +{ + fstring keystr; + TDB_DATA data; + struct tdb_print_db *pdb = get_print_db_byname(sharename); + int len; + + if (status) { + ZERO_STRUCTP(status); + } + + if (!pdb) + return 0; + + if (status) { + fstr_sprintf(keystr, "STATUS/%s", sharename); + data = tdb_fetch(pdb->tdb, string_tdb_data(keystr)); + if (data.dptr) { + if (data.dsize == sizeof(print_status_struct)) + /* this memcpy is ok since the status struct was + not packed before storing it in the tdb */ + memcpy(status, data.dptr, sizeof(print_status_struct)); + SAFE_FREE(data.dptr); + } + } + len = tdb_fetch_int32(pdb->tdb, "INFO/total_jobs"); + release_print_db(pdb); + return (len == -1 ? 0 : len); +} + +/**************************************************************************** + Determine the number of jobs in a queue. +****************************************************************************/ + +int print_queue_length(struct messaging_context *msg_ctx, int snum, + print_status_struct *pstatus) +{ + const char* sharename = lp_const_servicename( snum ); + print_status_struct status; + int len; + + ZERO_STRUCT( status ); + + /* make sure the database is up to date */ + if (print_cache_expired(lp_const_servicename(snum), True)) + print_queue_update(msg_ctx, snum, False); + + /* also fetch the queue status */ + memset(&status, 0, sizeof(status)); + len = get_queue_status(sharename, &status); + + if (pstatus) + *pstatus = status; + + return len; +} + +/*************************************************************************** + Allocate a jobid. Hold the lock for as short a time as possible. +***************************************************************************/ + +static WERROR allocate_print_jobid(struct tdb_print_db *pdb, int snum, + const char *sharename, uint32_t *pjobid) +{ + int i; + uint32_t jobid; + enum TDB_ERROR terr; + int ret; + + *pjobid = (uint32_t)-1; + + for (i = 0; i < 3; i++) { + /* Lock the database - only wait 20 seconds. */ + ret = tdb_lock_bystring_with_timeout(pdb->tdb, + "INFO/nextjob", 20); + if (ret != 0) { + DEBUG(0, ("allocate_print_jobid: " + "Failed to lock printing database %s\n", + sharename)); + terr = tdb_error(pdb->tdb); + return ntstatus_to_werror(map_nt_error_from_tdb(terr)); + } + + if (!tdb_fetch_uint32(pdb->tdb, "INFO/nextjob", &jobid)) { + terr = tdb_error(pdb->tdb); + if (terr != TDB_ERR_NOEXIST) { + DEBUG(0, ("allocate_print_jobid: " + "Failed to fetch INFO/nextjob " + "for print queue %s\n", sharename)); + tdb_unlock_bystring(pdb->tdb, "INFO/nextjob"); + return ntstatus_to_werror(map_nt_error_from_tdb(terr)); + } + DEBUG(10, ("allocate_print_jobid: " + "No existing jobid in %s\n", sharename)); + jobid = 0; + } + + DEBUG(10, ("allocate_print_jobid: " + "Read jobid %u from %s\n", jobid, sharename)); + + jobid = NEXT_JOBID(jobid); + + ret = tdb_store_int32(pdb->tdb, "INFO/nextjob", jobid); + if (ret != 0) { + terr = tdb_error(pdb->tdb); + DEBUG(3, ("allocate_print_jobid: " + "Failed to store INFO/nextjob.\n")); + tdb_unlock_bystring(pdb->tdb, "INFO/nextjob"); + return ntstatus_to_werror(map_nt_error_from_tdb(terr)); + } + + /* We've finished with the INFO/nextjob lock. */ + tdb_unlock_bystring(pdb->tdb, "INFO/nextjob"); + + if (!print_job_exists(sharename, jobid)) { + break; + } + DEBUG(10, ("allocate_print_jobid: " + "Found jobid %u in %s\n", jobid, sharename)); + } + + if (i > 2) { + DEBUG(0, ("allocate_print_jobid: " + "Failed to allocate a print job for queue %s\n", + sharename)); + /* Probably full... */ + return WERR_NO_SPOOL_SPACE; + } + + /* Store a dummy placeholder. */ + { + uint32_t tmp; + TDB_DATA dummy = { + .dsize = 0, + }; + if (tdb_store(pdb->tdb, print_key(jobid, &tmp), dummy, + TDB_INSERT) != 0) { + DEBUG(3, ("allocate_print_jobid: " + "jobid (%d) failed to store placeholder.\n", + jobid )); + terr = tdb_error(pdb->tdb); + return ntstatus_to_werror(map_nt_error_from_tdb(terr)); + } + } + + *pjobid = jobid; + return WERR_OK; +} + +/*************************************************************************** + Do all checks needed to determine if we can start a job. +***************************************************************************/ + +static WERROR print_job_checks(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, + int snum, int *njobs) +{ + const char *sharename = lp_const_servicename(snum); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + uint64_t dspace, dsize; + uint64_t minspace; + int ret; + + if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum, + PRINTER_ACCESS_USE))) { + DEBUG(3, ("print_job_checks: " + "job start denied by security descriptor\n")); + return WERR_ACCESS_DENIED; + } + + if (!print_time_access_check(server_info, msg_ctx, sharename)) { + DEBUG(3, ("print_job_checks: " + "job start denied by time check\n")); + return WERR_ACCESS_DENIED; + } + + /* see if we have sufficient disk space */ + if (lp_min_print_space(snum)) { + minspace = lp_min_print_space(snum); + ret = sys_fsusage(lp_path(talloc_tos(), lp_sub, snum), &dspace, &dsize); + if (ret == 0 && dspace < 2*minspace) { + DEBUG(3, ("print_job_checks: " + "disk space check failed.\n")); + return WERR_NO_SPOOL_SPACE; + } + } + + /* for autoloaded printers, check that the printcap entry still exists */ + if (lp_autoloaded(snum) && + !printer_list_printername_exists(sharename)) { + DEBUG(3, ("print_job_checks: printer name %s check failed.\n", + sharename)); + return WERR_ACCESS_DENIED; + } + + /* Insure the maximum queue size is not violated */ + *njobs = print_queue_length(msg_ctx, snum, NULL); + if (*njobs > lp_maxprintjobs(snum)) { + DEBUG(3, ("print_job_checks: Queue %s number of jobs (%d) " + "larger than max printjobs per queue (%d).\n", + sharename, *njobs, lp_maxprintjobs(snum))); + return WERR_NO_SPOOL_SPACE; + } + + return WERR_OK; +} + +/*************************************************************************** + Create a job file. +***************************************************************************/ + +static WERROR print_job_spool_file(int snum, uint32_t jobid, + const char *output_file, + struct printjob *pjob) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + WERROR werr; + SMB_STRUCT_STAT st; + const char *path; + int len; + mode_t mask; + + /* if this file is within the printer path, it means that smbd + * is spooling it and will pass us control when it is finished. + * Verify that the file name is ok, within path, and it is + * already already there */ + if (output_file) { + path = lp_path(talloc_tos(), lp_sub, snum); + len = strlen(path); + if (strncmp(output_file, path, len) == 0 && + (output_file[len - 1] == '/' || output_file[len] == '/')) { + + /* verify path is not too long */ + if (strlen(output_file) >= sizeof(pjob->filename)) { + return WERR_INVALID_NAME; + } + + /* verify that the file exists */ + if (sys_stat(output_file, &st, false) != 0) { + return WERR_INVALID_NAME; + } + + fstrcpy(pjob->filename, output_file); + + DEBUG(3, ("print_job_spool_file:" + "External spooling activated\n")); + + /* we do not open the file until spooling is done */ + pjob->fd = -1; + pjob->status = PJOB_SMBD_SPOOLING; + + return WERR_OK; + } + } + + slprintf(pjob->filename, sizeof(pjob->filename)-1, + "%s/%sXXXXXX", lp_path(talloc_tos(), lp_sub, snum), + PRINT_SPOOL_PREFIX); + mask = umask(S_IRWXO | S_IRWXG); + pjob->fd = mkstemp(pjob->filename); + umask(mask); + + if (pjob->fd == -1) { + werr = map_werror_from_unix(errno); + if (W_ERROR_EQUAL(werr, WERR_ACCESS_DENIED)) { + /* Common setup error, force a report. */ + DEBUG(0, ("print_job_spool_file: " + "insufficient permissions to open spool " + "file %s.\n", pjob->filename)); + } else { + /* Normal case, report at level 3 and above. */ + DEBUG(3, ("print_job_spool_file: " + "can't open spool file %s\n", + pjob->filename)); + } + return werr; + } + + return WERR_OK; +} + +/*************************************************************************** + Start spooling a job - return the jobid. +***************************************************************************/ + +WERROR print_job_start(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, + const char *clientmachine, + int snum, const char *docname, const char *filename, + struct spoolss_DeviceMode *devmode, uint32_t *_jobid) +{ + uint32_t jobid; + char *path = NULL, *userstr = NULL; + struct printjob pjob; + const char *sharename = lp_const_servicename(snum); + struct tdb_print_db *pdb = get_print_db_byname(sharename); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int njobs; + WERROR werr; + + if (!pdb) { + return WERR_INTERNAL_DB_CORRUPTION; + } + + path = lp_path(talloc_tos(), lp_sub, snum); + + werr = print_job_checks(server_info, msg_ctx, snum, &njobs); + if (!W_ERROR_IS_OK(werr)) { + release_print_db(pdb); + return werr; + } + + DEBUG(10, ("print_job_start: " + "Queue %s number of jobs (%d), max printjobs = %d\n", + sharename, njobs, lp_maxprintjobs(snum))); + + werr = allocate_print_jobid(pdb, snum, sharename, &jobid); + if (!W_ERROR_IS_OK(werr)) { + goto fail; + } + + /* create the database entry */ + + ZERO_STRUCT(pjob); + + pjob.pid = getpid(); + pjob.jobid = jobid; + pjob.sysjob = -1; + pjob.fd = -1; + pjob.starttime = time(NULL); + pjob.status = LPQ_SPOOLING; + pjob.size = 0; + pjob.spooled = False; + pjob.smbjob = True; + pjob.devmode = devmode; + + fstrcpy(pjob.jobname, docname); + + fstrcpy(pjob.clientmachine, clientmachine); + + userstr = talloc_sub_full(talloc_tos(), + sharename, + server_info->unix_info->sanitized_username, + path, server_info->unix_token->gid, + server_info->unix_info->sanitized_username, + server_info->info->domain_name, + lp_printjob_username(snum)); + if (userstr == NULL) { + werr = WERR_NOT_ENOUGH_MEMORY; + goto fail; + } + strlcpy(pjob.user, userstr, sizeof(pjob.user)); + TALLOC_FREE(userstr); + + fstrcpy(pjob.queuename, lp_const_servicename(snum)); + + /* we have a job entry - now create the spool file */ + werr = print_job_spool_file(snum, jobid, filename, &pjob); + if (!W_ERROR_IS_OK(werr)) { + goto fail; + } + + pjob_store(global_event_context(), msg_ctx, sharename, jobid, &pjob); + + /* Update the 'jobs added' entry used by print_queue_status. */ + add_to_jobs_list(pdb, jobid, "INFO/jobs_added"); + + /* Ensure we keep a rough count of the number of total jobs... */ + tdb_change_int32_atomic(pdb->tdb, "INFO/total_jobs", &njobs, 1); + + release_print_db(pdb); + + *_jobid = jobid; + return WERR_OK; + +fail: + if (jobid != -1) { + pjob_delete(global_event_context(), msg_ctx, sharename, jobid); + } + + release_print_db(pdb); + + DEBUG(3, ("print_job_start: returning fail. " + "Error = %s\n", win_errstr(werr))); + return werr; +} + +/**************************************************************************** + Update the number of pages spooled to jobid +****************************************************************************/ + +void print_job_endpage(struct messaging_context *msg_ctx, + int snum, uint32_t jobid) +{ + const char* sharename = lp_const_servicename(snum); + struct printjob *pjob; + TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx); + if (tmp_ctx == NULL) { + return; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob) { + goto err_out; + } + /* don't allow another process to get this info - it is meaningless */ + if (pjob->pid != getpid()) { + goto err_out; + } + + pjob->page_count++; + pjob_store(global_event_context(), msg_ctx, sharename, jobid, pjob); +err_out: + talloc_free(tmp_ctx); +} + +/**************************************************************************** + Print a file - called on closing the file. This spools the job. + If normal close is false then we're tearing down the jobs - treat as an + error. +****************************************************************************/ + +NTSTATUS print_job_end(struct messaging_context *msg_ctx, int snum, + uint32_t jobid, enum file_close_type close_type) +{ + const char* sharename = lp_const_servicename(snum); + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + struct printjob *pjob; + int ret; + SMB_STRUCT_STAT sbuf; + struct printif *current_printif = get_printer_fns(snum); + NTSTATUS status = NT_STATUS_UNSUCCESSFUL; + char *lpq_cmd; + TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx); + if (tmp_ctx == NULL) { + return NT_STATUS_NO_MEMORY; + } + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (!pjob) { + status = NT_STATUS_PRINT_CANCELLED; + goto err_out; + } + + if (pjob->spooled || pjob->pid != getpid()) { + status = NT_STATUS_ACCESS_DENIED; + goto err_out; + } + + if (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) { + if (pjob->status == PJOB_SMBD_SPOOLING) { + /* take over the file now, smbd is done */ + if (sys_stat(pjob->filename, &sbuf, false) != 0) { + status = map_nt_error_from_unix(errno); + DEBUG(3, ("print_job_end: " + "stat file failed for jobid %d\n", + jobid)); + goto fail; + } + + pjob->status = LPQ_SPOOLING; + + } else { + + if ((sys_fstat(pjob->fd, &sbuf, false) != 0)) { + status = map_nt_error_from_unix(errno); + close(pjob->fd); + DEBUG(3, ("print_job_end: " + "stat file failed for jobid %d\n", + jobid)); + goto fail; + } + + close(pjob->fd); + } + + pjob->size = sbuf.st_ex_size; + } else { + + /* + * Not a normal close, something has gone wrong. Cleanup. + */ + if (pjob->fd != -1) { + close(pjob->fd); + } + goto fail; + } + + /* Technically, this is not quite right. If the printer has a separator + * page turned on, the NT spooler prints the separator page even if the + * print job is 0 bytes. 010215 JRR */ + if (pjob->size == 0 || pjob->status == LPQ_DELETING) { + /* don't bother spooling empty files or something being deleted. */ + DEBUG(5,("print_job_end: canceling spool of %s (%s)\n", + pjob->filename, pjob->size ? "deleted" : "zero length" )); + unlink(pjob->filename); + pjob_delete(global_event_context(), msg_ctx, sharename, jobid); + return NT_STATUS_OK; + } + + /* don't strip out characters like '$' from the printername */ + lpq_cmd = talloc_string_sub2(tmp_ctx, + lp_lpq_command(snum), + "%p", + lp_printername(talloc_tos(), lp_sub, snum), + false, false, false); + if (lpq_cmd == NULL) { + status = NT_STATUS_PRINT_CANCELLED; + goto fail; + } + lpq_cmd = talloc_sub_full(tmp_ctx, + lp_servicename(talloc_tos(), lp_sub, snum), + current_user_info.unix_name, + "", + get_current_gid(NULL), + get_current_username(), + get_current_user_info_domain(), + lpq_cmd); + if (lpq_cmd == NULL) { + status = NT_STATUS_PRINT_CANCELLED; + goto fail; + } + + ret = (*(current_printif->job_submit))(snum, pjob, + current_printif->type, lpq_cmd); + if (ret) { + status = NT_STATUS_PRINT_CANCELLED; + goto fail; + } + + /* The print job has been successfully handed over to the back-end */ + + pjob->spooled = True; + pjob->status = LPQ_QUEUED; + pjob_store(global_event_context(), msg_ctx, sharename, jobid, pjob); + + /* make sure the database is up to date */ + if (print_cache_expired(lp_const_servicename(snum), True)) + print_queue_update(msg_ctx, snum, False); + + return NT_STATUS_OK; + +fail: + + /* The print job was not successfully started. Cleanup */ + /* Still need to add proper error return propagation! 010122:JRR */ + pjob->fd = -1; + unlink(pjob->filename); + pjob_delete(global_event_context(), msg_ctx, sharename, jobid); +err_out: + talloc_free(tmp_ctx); + return status; +} + +/**************************************************************************** + Get a snapshot of jobs in the system without traversing. +****************************************************************************/ + +static bool get_stored_queue_info(struct messaging_context *msg_ctx, + struct tdb_print_db *pdb, int snum, + int *pcount, print_queue_struct **ppqueue) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + TDB_DATA data, cgdata, jcdata; + print_queue_struct *queue = NULL; + uint32_t qcount = 0; + uint32_t extra_count = 0; + uint32_t changed_count = 0; + int total_count = 0; + size_t len = 0; + uint32_t i; + int max_reported_jobs = lp_max_reported_print_jobs(snum); + bool ret = false; + const char* sharename = lp_servicename(talloc_tos(), lp_sub, snum); + TALLOC_CTX *tmp_ctx = talloc_new(msg_ctx); + if (tmp_ctx == NULL) { + return false; + } + + /* make sure the database is up to date */ + if (print_cache_expired(lp_const_servicename(snum), True)) + print_queue_update(msg_ctx, snum, False); + + *pcount = 0; + *ppqueue = NULL; + + ZERO_STRUCT(data); + ZERO_STRUCT(cgdata); + + /* Get the stored queue data. */ + data = tdb_fetch(pdb->tdb, string_tdb_data("INFO/linear_queue_array")); + + if (data.dptr && data.dsize >= sizeof(qcount)) + len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount); + + /* Get the added jobs list. */ + cgdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_added")); + if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0)) + extra_count = cgdata.dsize/4; + + /* Get the changed jobs list. */ + jcdata = tdb_fetch(pdb->tdb, string_tdb_data("INFO/jobs_changed")); + if (jcdata.dptr != NULL && (jcdata.dsize % 4 == 0)) + changed_count = jcdata.dsize / 4; + + DEBUG(5,("get_stored_queue_info: qcount = %u, extra_count = %u\n", (unsigned int)qcount, (unsigned int)extra_count)); + + /* Allocate the queue size. */ + if (qcount == 0 && extra_count == 0) + goto out; + + if ((queue = SMB_MALLOC_ARRAY(print_queue_struct, qcount + extra_count)) == NULL) + goto out; + + /* Retrieve the linearised queue data. */ + + for(i = 0; i < qcount; i++) { + uint32_t qjob, qsize, qpage_count, qstatus, qpriority, qtime; + len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff", + &qjob, + &qsize, + &qpage_count, + &qstatus, + &qpriority, + &qtime, + queue[i].fs_user, + queue[i].fs_file); + queue[i].sysjob = qjob; + queue[i].size = qsize; + queue[i].page_count = qpage_count; + queue[i].status = qstatus; + queue[i].priority = qpriority; + queue[i].time = qtime; + } + + total_count = qcount; + + /* Add new jobids to the queue. */ + for (i = 0; i < extra_count; i++) { + uint32_t jobid; + struct printjob *pjob; + + jobid = IVAL(cgdata.dptr, i*4); + DEBUG(5,("get_stored_queue_info: added job = %u\n", (unsigned int)jobid)); + pjob = print_job_find(tmp_ctx, lp_const_servicename(snum), jobid); + if (!pjob) { + DEBUG(5,("get_stored_queue_info: failed to find added job = %u\n", (unsigned int)jobid)); + remove_from_jobs_added(sharename, jobid); + continue; + } + + queue[total_count].sysjob = pjob->sysjob; + queue[total_count].size = pjob->size; + queue[total_count].page_count = pjob->page_count; + queue[total_count].status = pjob->status; + queue[total_count].priority = 1; + queue[total_count].time = pjob->starttime; + fstrcpy(queue[total_count].fs_user, pjob->user); + fstrcpy(queue[total_count].fs_file, pjob->jobname); + total_count++; + talloc_free(pjob); + } + + /* Update the changed jobids. */ + for (i = 0; i < changed_count; i++) { + uint32_t jobid = IVAL(jcdata.dptr, i * 4); + struct printjob *pjob; + uint32_t j; + bool found = false; + + pjob = print_job_find(tmp_ctx, sharename, jobid); + if (pjob == NULL) { + DEBUG(5,("get_stored_queue_info: failed to find " + "changed job = %u\n", + (unsigned int)jobid)); + remove_from_jobs_changed(sharename, jobid); + continue; + } + + for (j = 0; j < total_count; j++) { + if (queue[j].sysjob == pjob->sysjob) { + found = true; + break; + } + } + + if (found) { + DEBUG(5,("get_stored_queue_info: changed job: %u\n", + (unsigned int)jobid)); + + queue[j].sysjob = pjob->sysjob; + queue[j].size = pjob->size; + queue[j].page_count = pjob->page_count; + queue[j].status = pjob->status; + queue[j].priority = 1; + queue[j].time = pjob->starttime; + fstrcpy(queue[j].fs_user, pjob->user); + fstrcpy(queue[j].fs_file, pjob->jobname); + talloc_free(pjob); + + DEBUG(5,("updated queue[%u], jobid: %u, sysjob: %u, " + "jobname: %s\n", + (unsigned int)j, (unsigned int)jobid, + (unsigned int)queue[j].sysjob, pjob->jobname)); + } + + remove_from_jobs_changed(sharename, jobid); + } + + /* Sort the queue by submission time otherwise they are displayed + in hash order. */ + + TYPESAFE_QSORT(queue, total_count, printjob_comp); + + DEBUG(5,("get_stored_queue_info: total_count = %u\n", (unsigned int)total_count)); + + if (max_reported_jobs && total_count > max_reported_jobs) + total_count = max_reported_jobs; + + *ppqueue = queue; + *pcount = total_count; + + ret = true; + + out: + + SAFE_FREE(data.dptr); + SAFE_FREE(cgdata.dptr); + talloc_free(tmp_ctx); + return ret; +} + +/**************************************************************************** + Get a printer queue listing. + set queue = NULL and status = NULL if you just want to update the cache +****************************************************************************/ + +int print_queue_status(struct messaging_context *msg_ctx, int snum, + print_queue_struct **ppqueue, + print_status_struct *status) +{ + fstring keystr; + TDB_DATA data, key; + const char *sharename; + struct tdb_print_db *pdb; + int count = 0; + + /* make sure the database is up to date */ + + if (print_cache_expired(lp_const_servicename(snum), True)) + print_queue_update(msg_ctx, snum, False); + + /* return if we are done */ + if ( !ppqueue || !status ) + return 0; + + *ppqueue = NULL; + sharename = lp_const_servicename(snum); + pdb = get_print_db_byname(sharename); + + if (!pdb) + return 0; + + /* + * Fetch the queue status. We must do this first, as there may + * be no jobs in the queue. + */ + + ZERO_STRUCTP(status); + slprintf(keystr, sizeof(keystr)-1, "STATUS/%s", sharename); + key = string_tdb_data(keystr); + + data = tdb_fetch(pdb->tdb, key); + if (data.dptr) { + if (data.dsize == sizeof(*status)) { + /* this memcpy is ok since the status struct was + not packed before storing it in the tdb */ + memcpy(status, data.dptr, sizeof(*status)); + } + SAFE_FREE(data.dptr); + } + + /* + * Now, fetch the print queue information. We first count the number + * of entries, and then only retrieve the queue if necessary. + */ + + if (!get_stored_queue_info(msg_ctx, pdb, snum, &count, ppqueue)) { + release_print_db(pdb); + return 0; + } + + release_print_db(pdb); + return count; +} + +/**************************************************************************** + Pause a queue. +****************************************************************************/ + +WERROR print_queue_pause(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, int snum) +{ + int ret; + struct printif *current_printif = get_printer_fns( snum ); + + if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum, + PRINTER_ACCESS_ADMINISTER))) { + return WERR_ACCESS_DENIED; + } + + + become_root(); + + ret = (*(current_printif->queue_pause))(snum); + + unbecome_root(); + + if (ret != 0) { + return WERR_INVALID_PARAMETER; + } + + /* force update the database */ + print_cache_flush(lp_const_servicename(snum)); + + /* Send a printer notify message */ + + notify_printer_status(global_event_context(), msg_ctx, snum, + PRINTER_STATUS_PAUSED); + + return WERR_OK; +} + +/**************************************************************************** + Resume a queue. +****************************************************************************/ + +WERROR print_queue_resume(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, int snum) +{ + int ret; + struct printif *current_printif = get_printer_fns( snum ); + + if (!W_ERROR_IS_OK(print_access_check(server_info, msg_ctx, snum, + PRINTER_ACCESS_ADMINISTER))) { + return WERR_ACCESS_DENIED; + } + + become_root(); + + ret = (*(current_printif->queue_resume))(snum); + + unbecome_root(); + + if (ret != 0) { + return WERR_INVALID_PARAMETER; + } + + /* make sure the database is up to date */ + if (print_cache_expired(lp_const_servicename(snum), True)) + print_queue_update(msg_ctx, snum, True); + + /* Send a printer notify message */ + + notify_printer_status(global_event_context(), msg_ctx, snum, + PRINTER_STATUS_OK); + + return WERR_OK; +} + +/**************************************************************************** + Purge a queue - implemented by deleting all jobs that we can delete. +****************************************************************************/ + +WERROR print_queue_purge(const struct auth_session_info *server_info, + struct messaging_context *msg_ctx, int snum) +{ + print_queue_struct *queue; + print_status_struct status; + int njobs, i; + bool can_job_admin; + + /* Force and update so the count is accurate (i.e. not a cached count) */ + print_queue_update(msg_ctx, snum, True); + + can_job_admin = W_ERROR_IS_OK(print_access_check(server_info, + msg_ctx, + snum, + JOB_ACCESS_ADMINISTER)); + njobs = print_queue_status(msg_ctx, snum, &queue, &status); + + if ( can_job_admin ) + become_root(); + + for (i = 0; i < njobs; i++) { + struct tdb_print_db *pdb; + int jobid; + bool owner; + pdb = get_print_db_byname(lp_const_servicename(snum)); + if (pdb == NULL) { + DEBUG(1, ("failed to find printdb for %s\n", + lp_const_servicename(snum))); + continue; + } + jobid = sysjob_to_jobid_pdb(pdb, queue[i].sysjob); + if (jobid == (uint32_t)-1) { + DEBUG(2, ("jobid for system job %d not found\n", + queue[i].sysjob)); + continue; /* unix job */ + } + owner = is_owner(server_info, lp_const_servicename(snum), + jobid); + + if (owner || can_job_admin) { + print_job_delete1(global_event_context(), msg_ctx, + snum, jobid); + } + } + + if ( can_job_admin ) + unbecome_root(); + + /* update the cache */ + print_queue_update(msg_ctx, snum, True); + + SAFE_FREE(queue); + + return WERR_OK; +} diff --git a/source3/printing/printing_db.c b/source3/printing/printing_db.c new file mode 100644 index 0000000..d54a39a --- /dev/null +++ b/source3/printing/printing_db.c @@ -0,0 +1,228 @@ +/* + Unix SMB/Netbios implementation. + Version 3.0 + printing backend routines + Copyright (C) Andrew Tridgell 1992-2000 + Copyright (C) Jeremy Allison 2002 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/passwd.h" /* uid_wrapper */ +#include "system/filesys.h" +#include "printing.h" +#include "util_tdb.h" +#include "lib/util/string_wrappers.h" + +static struct tdb_print_db *print_db_head; + +/**************************************************************************** + Function to find or create the printer specific job tdb given a printername. + Limits the number of tdb's open to MAX_PRINT_DBS_OPEN. +****************************************************************************/ + +struct tdb_print_db *get_print_db_byname(const char *printername) +{ + struct tdb_print_db *p = NULL, *last_entry = NULL; + size_t num_open = 0; + char *printdb_path = NULL; + bool done_become_root = False; + char *print_cache_path; + int ret; + + SMB_ASSERT(printername != NULL); + + for (p = print_db_head, last_entry = print_db_head; p; p = p->next) { + /* Ensure the list terminates... JRA. */ + SMB_ASSERT(p->next != print_db_head); + + if (p->tdb && strequal(p->printer_name, printername)) { + DLIST_PROMOTE(print_db_head, p); + p->ref_count++; + return p; + } + num_open++; + last_entry = p; + } + + /* Not found. */ + if (num_open >= MAX_PRINT_DBS_OPEN) { + /* Try and recycle the last entry. */ + if (print_db_head && last_entry) { + DLIST_PROMOTE(print_db_head, last_entry); + } + + for (p = print_db_head; p; p = p->next) { + if (p->ref_count) + continue; + if (p->tdb) { + if (tdb_close(p->tdb)) { + DEBUG(0,("get_print_db: Failed to close tdb for printer %s\n", + p->printer_name )); + return NULL; + } + } + p->tdb = NULL; + p->ref_count = 0; + memset(p->printer_name, '\0', sizeof(p->printer_name)); + break; + } + if (p && print_db_head) { + DLIST_PROMOTE(print_db_head, p); + p = print_db_head; + } + } + + if (!p) { + /* Create one. */ + p = SMB_MALLOC_P(struct tdb_print_db); + if (!p) { + DEBUG(0,("get_print_db: malloc fail !\n")); + return NULL; + } + ZERO_STRUCTP(p); + DLIST_ADD(print_db_head, p); + } + + print_cache_path = cache_path(talloc_tos(), "printing/"); + if (print_cache_path == NULL) { + DLIST_REMOVE(print_db_head, p); + SAFE_FREE(p); + return NULL; + } + ret = asprintf(&printdb_path, "%s%s.tdb", + print_cache_path, printername); + TALLOC_FREE(print_cache_path); + if (ret < 0) { + DLIST_REMOVE(print_db_head, p); + SAFE_FREE(p); + return NULL; + } + + if (geteuid() != sec_initial_uid()) { + become_root(); + done_become_root = True; + } + + p->tdb = tdb_open_log(printdb_path, 5000, TDB_DEFAULT, O_RDWR|O_CREAT, + 0600); + + if (done_become_root) + unbecome_root(); + + if (!p->tdb) { + DEBUG(0,("get_print_db: Failed to open printer backend database %s.\n", + printdb_path )); + DLIST_REMOVE(print_db_head, p); + SAFE_FREE(printdb_path); + SAFE_FREE(p); + return NULL; + } + SAFE_FREE(printdb_path); + fstrcpy(p->printer_name, printername); + p->ref_count++; + return p; +} + +/*************************************************************************** + Remove a reference count. +****************************************************************************/ + +void release_print_db( struct tdb_print_db *pdb) +{ + pdb->ref_count--; + SMB_ASSERT(pdb->ref_count >= 0); +} + +/*************************************************************************** + Close all open print db entries. +****************************************************************************/ + +void close_all_print_db(void) +{ + struct tdb_print_db *p = NULL, *next_p = NULL; + + for (p = print_db_head; p; p = next_p) { + next_p = p->next; + + if (p->tdb) + tdb_close(p->tdb); + DLIST_REMOVE(print_db_head, p); + ZERO_STRUCTP(p); + SAFE_FREE(p); + } +} + + +/**************************************************************************** + Fetch and clean the pid_t record list for all pids interested in notify + messages. data needs freeing on exit. +****************************************************************************/ + +TDB_DATA get_printer_notify_pid_list(struct tdb_context *tdb, const char *printer_name, bool cleanlist) +{ + TDB_DATA data; + size_t i; + + ZERO_STRUCT(data); + + data = tdb_fetch_bystring( tdb, NOTIFY_PID_LIST_KEY ); + + if (!data.dptr) { + ZERO_STRUCT(data); + return data; + } + + if (data.dsize % 8) { + DEBUG(0,("get_printer_notify_pid_list: Size of record for printer %s not a multiple of 8 !\n", printer_name )); + tdb_delete_bystring(tdb, NOTIFY_PID_LIST_KEY ); + SAFE_FREE(data.dptr); + ZERO_STRUCT(data); + return data; + } + + if (!cleanlist) + return data; + + /* + * Weed out all dead entries. + */ + + for( i = 0; i < data.dsize; i += 8) { + pid_t pid = (pid_t)IVAL(data.dptr, i); + + if (pid == getpid()) + continue; + + /* Entry is dead if process doesn't exist or refcount is zero. */ + + while ((i < data.dsize) && ((IVAL(data.dptr, i + 4) == 0) || !process_exists_by_pid(pid))) { + + /* Refcount == zero is a logic error and should never happen. */ + if (IVAL(data.dptr, i + 4) == 0) { + DEBUG(0,("get_printer_notify_pid_list: Refcount == 0 for pid = %u printer %s !\n", + (unsigned int)pid, printer_name )); + } + + if (data.dsize - i > 8) + memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8); + data.dsize -= 8; + } + } + + return data; +} + + diff --git a/source3/printing/printspoolss.c b/source3/printing/printspoolss.c new file mode 100644 index 0000000..94404f7 --- /dev/null +++ b/source3/printing/printspoolss.c @@ -0,0 +1,406 @@ +/* + Unix SMB/CIFS implementation. + Printing routines that bridge to spoolss + Copyright (C) Simo Sorce 2010 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "printing.h" +#include "rpc_client/rpc_client.h" +#include "../librpc/gen_ndr/ndr_spoolss_c.h" +#include "rpc_server/rpc_ncacn_np.h" +#include "smbd/globals.h" +#include "../libcli/security/security.h" +#include "smbd/fd_handle.h" +#include "source3/printing/rap_jobid.h" + +struct print_file_data { + char *svcname; + char *docname; + char *filename; + struct policy_handle handle; + uint32_t jobid; + uint16_t rap_jobid; +}; + +uint16_t print_spool_rap_jobid(struct print_file_data *print_file) +{ + if (print_file == NULL) { + return 0; + } + + return print_file->rap_jobid; +} + +void print_spool_terminate(struct connection_struct *conn, + struct print_file_data *print_file); + +/*************************************************************************** + * Open a Document over spoolss + ***************************************************************************/ + +#define DOCNAME_DEFAULT "Remote Downlevel Document" + +NTSTATUS print_spool_open(files_struct *fsp, + const char *fname, + uint64_t current_vuid) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + NTSTATUS status; + TALLOC_CTX *tmp_ctx; + struct print_file_data *pf; + struct dcerpc_binding_handle *b = NULL; + struct spoolss_DevmodeContainer devmode_ctr; + struct spoolss_DocumentInfoCtr info_ctr; + struct spoolss_DocumentInfo1 *info1; + int fd = -1; + WERROR werr; + mode_t mask; + + tmp_ctx = talloc_new(fsp); + if (!tmp_ctx) { + return NT_STATUS_NO_MEMORY; + } + + pf = talloc_zero(fsp, struct print_file_data); + if (!pf) { + status = NT_STATUS_NO_MEMORY; + goto done; + } + pf->svcname = lp_servicename(pf, lp_sub, SNUM(fsp->conn)); + + /* the document name is derived from the file name. + * "Remote Downlevel Document" is added in front to + * mimic what windows does in this case */ + pf->docname = talloc_strdup(pf, DOCNAME_DEFAULT); + if (!pf->docname) { + status = NT_STATUS_NO_MEMORY; + goto done; + } + if (fname) { + const char *p = strrchr(fname, '/'); + if (!p) { + p = fname; + } + pf->docname = talloc_asprintf_append(pf->docname, " %s", p); + if (!pf->docname) { + status = NT_STATUS_NO_MEMORY; + goto done; + } + } + + /* + * Ok, now we have to open an actual file. + * Here is the reason: + * We want to write the spool job to this file in + * smbd for scalability reason (and also because + * apparently window printer drivers can seek when + * spooling to a file). + * So we first create a file, and then we pass it + * to spoolss in output_file so it can monitor and + * take over once we call EndDocPrinter(). + * Of course we will not start writing until + * StartDocPrinter() actually gives the ok. + * smbd spooler files do not include a print jobid + * path component, as the jobid is only known after + * calling StartDocPrinter(). + */ + + pf->filename = talloc_asprintf(pf, "%s/%sXXXXXX", + lp_path(talloc_tos(), + lp_sub, + SNUM(fsp->conn)), + PRINT_SPOOL_PREFIX); + if (!pf->filename) { + status = NT_STATUS_NO_MEMORY; + goto done; + } + errno = 0; + mask = umask(S_IRWXO | S_IRWXG); + fd = mkstemp(pf->filename); + umask(mask); + if (fd == -1) { + if (errno == EACCES) { + /* Common setup error, force a report. */ + DEBUG(0, ("Insufficient permissions " + "to open spool file %s.\n", + pf->filename)); + } else { + /* Normal case, report at level 3 and above. */ + DEBUG(3, ("can't open spool file %s,\n", + pf->filename)); + DEBUGADD(3, ("errno = %d (%s).\n", + errno, strerror(errno))); + } + status = map_nt_error_from_unix(errno); + goto done; + } + + /* now open a document over spoolss so that it does + * all printer verification, and eventually assigns + * a job id */ + + status = rpc_pipe_open_interface(fsp->conn, + &ndr_table_spoolss, + fsp->conn->session_info, + fsp->conn->sconn->remote_address, + fsp->conn->sconn->local_address, + fsp->conn->sconn->msg_ctx, + &fsp->conn->spoolss_pipe); + if (!NT_STATUS_IS_OK(status)) { + goto done; + } + b = fsp->conn->spoolss_pipe->binding_handle; + + ZERO_STRUCT(devmode_ctr); + + status = dcerpc_spoolss_OpenPrinter(b, pf, pf->svcname, + "RAW", devmode_ctr, + PRINTER_ACCESS_USE, + &pf->handle, &werr); + if (!NT_STATUS_IS_OK(status)) { + goto done; + } + if (!W_ERROR_IS_OK(werr)) { + status = werror_to_ntstatus(werr); + goto done; + } + + info1 = talloc(tmp_ctx, struct spoolss_DocumentInfo1); + if (info1 == NULL) { + status = NT_STATUS_NO_MEMORY; + goto done; + } + info1->document_name = pf->docname; + info1->output_file = pf->filename; + info1->datatype = "RAW"; + + info_ctr.level = 1; + info_ctr.info.info1 = info1; + + status = dcerpc_spoolss_StartDocPrinter(b, tmp_ctx, + &pf->handle, + &info_ctr, + &pf->jobid, + &werr); + if (!NT_STATUS_IS_OK(status)) { + goto done; + } + if (!W_ERROR_IS_OK(werr)) { + status = werror_to_ntstatus(werr); + goto done; + } + + /* Convert to RAP id. */ + pf->rap_jobid = pjobid_to_rap(pf->svcname, pf->jobid); + if (pf->rap_jobid == 0) { + /* No errno around here */ + status = NT_STATUS_ACCESS_DENIED; + goto done; + } + + /* setup a full fsp */ + fsp->fsp_name = synthetic_smb_fname(fsp, + pf->filename, + NULL, + NULL, + 0, + 0); + if (fsp->fsp_name == NULL) { + status = NT_STATUS_NO_MEMORY; + goto done; + } + + if (sys_fstat(fd, &fsp->fsp_name->st, false) != 0) { + status = map_nt_error_from_unix(errno); + goto done; + } + + fsp->file_id = vfs_file_id_from_sbuf(fsp->conn, &fsp->fsp_name->st); + fsp_set_fd(fsp, fd); + + fsp->vuid = current_vuid; + fsp->fsp_flags.can_lock = false; + fsp->fsp_flags.can_read = false; + fsp->access_mask = FILE_GENERIC_WRITE; + fsp->fsp_flags.can_write = true; + fsp->fsp_flags.modified = false; + fsp->oplock_type = NO_OPLOCK; + fsp->sent_oplock_break = NO_BREAK_SENT; + fsp->fsp_flags.is_directory = false; + fsp->fsp_flags.delete_on_close = false; + fsp->fsp_flags.is_fsa = true; + + fsp->print_file = pf; + + status = NT_STATUS_OK; +done: + if (!NT_STATUS_IS_OK(status)) { + if (fd != -1) { + close(fd); + if (fsp->print_file) { + unlink(fsp->print_file->filename); + } + } + /* We need to delete the job from spoolss too */ + if (pf && pf->jobid) { + print_spool_terminate(fsp->conn, pf); + } + } + talloc_free(tmp_ctx); + return status; +} + +int print_spool_write(files_struct *fsp, + const char *data, uint32_t size, + off_t offset, uint32_t *written) +{ + SMB_STRUCT_STAT st; + ssize_t n; + int ret; + + *written = 0; + + /* first of all stat file to find out if it is still there. + * spoolss may have deleted it to signal someone has killed + * the job through it's interface */ + + if (sys_fstat(fsp_get_io_fd(fsp), &st, false) != 0) { + ret = errno; + DEBUG(3, ("printfile_offset: sys_fstat failed on %s (%s)\n", + fsp_str_dbg(fsp), strerror(ret))); + return ret; + } + + /* check if the file is unlinked, this will signal spoolss has + * killed it, just return an error and close the file */ + if (st.st_ex_nlink == 0) { + close(fsp_get_io_fd(fsp)); + return EBADF; + } + + /* When print files go beyond 4GB, the 32-bit offset sent in + * old SMBwrite calls is relative to the current 4GB chunk + * we're writing to. + * Discovered by Sebastian Kloska . + */ + if (offset < 0xffffffff00000000LL) { + offset = (st.st_ex_size & 0xffffffff00000000LL) + offset; + } + + n = write_data_at_offset(fsp_get_io_fd(fsp), data, size, offset); + if (n == -1) { + ret = errno; + print_spool_terminate(fsp->conn, fsp->print_file); + } else { + *written = n; + ret = 0; + } + + return ret; +} + +void print_spool_end(files_struct *fsp, enum file_close_type close_type) +{ + NTSTATUS status; + WERROR werr; + struct dcerpc_binding_handle *b = NULL; + + if (fsp->fsp_flags.delete_on_close) { + int ret; + + /* + * Job was requested to be cancelled by setting + * delete on close so truncate the job file. + * print_job_end() which is called from + * _spoolss_EndDocPrinter() will take + * care of deleting it for us. + */ + ret = ftruncate(fsp_get_io_fd(fsp), 0); + if (ret == -1) { + DBG_ERR("ftruncate failed: %s\n", strerror(errno)); + } + } + + b = fsp->conn->spoolss_pipe->binding_handle; + + switch (close_type) { + case NORMAL_CLOSE: + case SHUTDOWN_CLOSE: + /* this also automatically calls spoolss_EndDocPrinter */ + status = dcerpc_spoolss_ClosePrinter(b, fsp->print_file, + &fsp->print_file->handle, + &werr); + if (!NT_STATUS_IS_OK(status) || + !NT_STATUS_IS_OK(status = werror_to_ntstatus(werr))) { + DEBUG(3, ("Failed to close printer %s [%s]\n", + fsp->print_file->svcname, nt_errstr(status))); + } + break; + case ERROR_CLOSE: + print_spool_terminate(fsp->conn, fsp->print_file); + break; + } +} + + +void print_spool_terminate(struct connection_struct *conn, + struct print_file_data *print_file) +{ + NTSTATUS status; + WERROR werr; + struct dcerpc_binding_handle *b = NULL; + + rap_jobid_delete(print_file->svcname, print_file->jobid); + + status = rpc_pipe_open_interface(conn, + &ndr_table_spoolss, + conn->session_info, + conn->sconn->remote_address, + conn->sconn->local_address, + conn->sconn->msg_ctx, + &conn->spoolss_pipe); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("print_spool_terminate: " + "Failed to get spoolss pipe [%s]\n", + nt_errstr(status))); + return; + } + b = conn->spoolss_pipe->binding_handle; + + status = dcerpc_spoolss_SetJob(b, print_file, + &print_file->handle, + print_file->jobid, + NULL, SPOOLSS_JOB_CONTROL_DELETE, + &werr); + if (!NT_STATUS_IS_OK(status) || + !NT_STATUS_IS_OK(status = werror_to_ntstatus(werr))) { + DEBUG(3, ("Failed to delete job %d [%s]\n", + print_file->jobid, nt_errstr(status))); + return; + } + status = dcerpc_spoolss_ClosePrinter(b, print_file, + &print_file->handle, + &werr); + if (!NT_STATUS_IS_OK(status) || + !NT_STATUS_IS_OK(status = werror_to_ntstatus(werr))) { + DEBUG(3, ("Failed to close printer %s [%s]\n", + print_file->svcname, nt_errstr(status))); + return; + } +} diff --git a/source3/printing/queue_process.c b/source3/printing/queue_process.c new file mode 100644 index 0000000..6613e8f --- /dev/null +++ b/source3/printing/queue_process.c @@ -0,0 +1,451 @@ +/* + Unix SMB/Netbios implementation. + Version 3.0 + printing backend routines + Copyright (C) Andrew Tridgell 1992-2000 + Copyright (C) Jeremy Allison 2002 + Copyright (C) Simo Sorce 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include +#include "smbd/globals.h" +#include "include/messages.h" +#include "lib/util/util_process.h" +#include "lib/util/sys_rw.h" +#include "printing.h" +#include "printing/pcap.h" +#include "printing/printer_list.h" +#include "printing/queue_process.h" +#include "locking/proto.h" +#include "locking/share_mode_lock.h" +#include "smbd/smbd.h" +#include "rpc_server/rpc_config.h" +#include "printing/load.h" +#include "rpc_server/spoolss/srv_spoolss_nt.h" +#include "auth.h" +#include "nt_printing.h" +#include "util_event.h" +#include "lib/global_contexts.h" +#include "lib/util/pidfile.h" + +/** + * @brief Purge stale printers and reload from pre-populated pcap cache. + * + * This function should normally only be called as a callback on a successful + * pcap_cache_reload(). + * + * This function can cause DELETION of printers and drivers from our registry, + * so calling it on a failed pcap reload may REMOVE permanently all printers + * and drivers. + * + * @param[in] ev The event context. + * + * @param[in] msg_ctx The messaging context. + */ +static void delete_and_reload_printers_full(struct tevent_context *ev, + struct messaging_context *msg_ctx) +{ + struct auth_session_info *session_info = NULL; + struct spoolss_PrinterInfo2 *pinfo2 = NULL; + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + int n_services; + int pnum; + int snum; + const char *pname; + const char *sname; + NTSTATUS status; + + n_services = lp_numservices(); + pnum = lp_servicenumber(PRINTERS_NAME); + + status = make_session_info_system(talloc_tos(), &session_info); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(3, ("reload_printers: " + "Could not create system session_info\n")); + /* can't remove stale printers before we + * are fully initialized */ + return; + } + + /* + * Add default config for printers added to smb.conf file and remove + * stale printers + */ + for (snum = 0; snum < n_services; snum++) { + /* avoid removing PRINTERS_NAME */ + if (snum == pnum) { + continue; + } + + /* skip no-printer services */ + if (!snum_is_shared_printer(snum)) { + continue; + } + + sname = lp_const_servicename(snum); + pname = lp_printername(session_info, lp_sub, snum); + + /* check printer, but avoid removing non-autoloaded printers */ + if (lp_autoloaded(snum) && + !printer_list_printername_exists(pname)) { + DEBUG(3, ("removing stale printer %s\n", pname)); + + if (is_printer_published(session_info, session_info, + msg_ctx, + NULL, + lp_servicename(session_info, + lp_sub, + snum), + &pinfo2)) { + nt_printer_publish(session_info, + session_info, + msg_ctx, + pinfo2, + DSPRINT_UNPUBLISH); + TALLOC_FREE(pinfo2); + } + nt_printer_remove(session_info, session_info, msg_ctx, + pname); + } else { + DEBUG(8, ("Adding default registry entry for printer " + "[%s], if it doesn't exist.\n", sname)); + nt_printer_add(session_info, session_info, msg_ctx, + sname); + } + } + + /* finally, purge old snums */ + delete_and_reload_printers(); + + TALLOC_FREE(session_info); +} + + +/**************************************************************************** + Notify smbds of new printcap data +**************************************************************************/ +static void reload_pcap_change_notify(struct tevent_context *ev, + struct messaging_context *msg_ctx) +{ + /* + * Reload the printers first in the background process so that + * newly added printers get default values created in the registry. + * + * This will block the process for some time (~1 sec per printer), but + * it doesn't block smbd's serving clients. + */ + delete_and_reload_printers_full(ev, msg_ctx); + + messaging_send_all(msg_ctx, MSG_PRINTER_PCAP, NULL, 0); +} + +struct bq_state { + struct tevent_context *ev; + struct messaging_context *msg; + struct idle_event *housekeep; + struct tevent_signal *sighup_handler; + struct tevent_signal *sigchld_handler; +}; + +static bool print_queue_housekeeping(const struct timeval *now, void *pvt) +{ + struct bq_state *state; + + state = talloc_get_type_abort(pvt, struct bq_state); + + DEBUG(5, ("print queue housekeeping\n")); + pcap_cache_reload(state->ev, state->msg, reload_pcap_change_notify); + + return true; +} + +static bool printing_subsystem_queue_tasks(struct bq_state *state) +{ + uint32_t housekeeping_period = lp_printcap_cache_time(); + + /* cancel any existing housekeeping event */ + TALLOC_FREE(state->housekeep); + + if ((housekeeping_period == 0) || !lp_load_printers()) { + DEBUG(4, ("background print queue housekeeping disabled\n")); + return true; + } + + state->housekeep = event_add_idle(state->ev, NULL, + timeval_set(housekeeping_period, 0), + "print_queue_housekeeping", + print_queue_housekeeping, state); + if (state->housekeep == NULL) { + DEBUG(0,("Could not add print_queue_housekeeping event\n")); + return false; + } + + return true; +} + +static void bq_reopen_logs(char *logfile) +{ + if (logfile) { + lp_set_logfile(logfile); + } + reopen_logs(); +} + +static void bq_sig_hup_handler(struct tevent_context *ev, + struct tevent_signal *se, + int signum, + int count, + void *siginfo, + void *pvt) +{ + struct bq_state *state; + + state = talloc_get_type_abort(pvt, struct bq_state); + change_to_root_user(); + + DEBUG(1, ("Reloading pcap cache after SIGHUP\n")); + pcap_cache_reload(state->ev, state->msg, + reload_pcap_change_notify); + printing_subsystem_queue_tasks(state); + bq_reopen_logs(NULL); +} + +static void bq_sig_chld_handler(struct tevent_context *ev_ctx, + struct tevent_signal *se, + int signum, int count, + void *siginfo, void *pvt) +{ + int status; + pid_t pid; + + do { + do { + pid = waitpid(-1, &status, WNOHANG); + } while ((pid == -1) && (errno == EINTR)); + + if (WIFEXITED(status)) { + DBG_INFO("Bq child process %d terminated with %d\n", + (int)pid, + WEXITSTATUS(status)); + } else { + DBG_NOTICE("Bq child process %d terminated abnormally\n", + (int)pid); + } + } while (pid > 0); +} + +static void bq_smb_conf_updated(struct messaging_context *msg_ctx, + void *private_data, + uint32_t msg_type, + struct server_id server_id, + DATA_BLOB *data) +{ + struct bq_state *state; + + state = talloc_get_type_abort(private_data, struct bq_state); + + DEBUG(10,("smb_conf_updated: Got message saying smb.conf was " + "updated. Reloading.\n")); + change_to_root_user(); + pcap_cache_reload(state->ev, msg_ctx, reload_pcap_change_notify); + printing_subsystem_queue_tasks(state); +} + +static int bq_state_destructor(struct bq_state *s) +{ + struct messaging_context *msg_ctx = s->msg; + TALLOC_FREE(s->sighup_handler); + TALLOC_FREE(s->sigchld_handler); + messaging_deregister(msg_ctx, MSG_PRINTER_DRVUPGRADE, NULL); + messaging_deregister(msg_ctx, MSG_PRINTER_UPDATE, NULL); + messaging_deregister(msg_ctx, MSG_SMB_CONF_UPDATED, s); + return 0; +} + +struct bq_state *register_printing_bq_handlers( + TALLOC_CTX *mem_ctx, + struct messaging_context *msg_ctx) +{ + struct bq_state *state = NULL; + NTSTATUS status; + bool ok; + + state = talloc_zero(mem_ctx, struct bq_state); + if (state == NULL) { + return NULL; + } + state->ev = messaging_tevent_context(msg_ctx); + state->msg = msg_ctx; + + status = messaging_register( + msg_ctx, state, MSG_SMB_CONF_UPDATED, bq_smb_conf_updated); + if (!NT_STATUS_IS_OK(status)) { + goto fail; + } + status = messaging_register( + msg_ctx, NULL, MSG_PRINTER_UPDATE, print_queue_receive); + if (!NT_STATUS_IS_OK(status)) { + goto fail_dereg_smb_conf_updated; + } + status = messaging_register( + msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE, do_drv_upgrade_printer); + if (!NT_STATUS_IS_OK(status)) { + goto fail_dereg_printer_update; + } + + state->sighup_handler = tevent_add_signal( + state->ev, state, SIGHUP, 0, bq_sig_hup_handler, state); + if (state->sighup_handler == NULL) { + goto fail_dereg_printer_drvupgrade; + } + state->sigchld_handler = tevent_add_signal( + state->ev, state, SIGCHLD, 0, bq_sig_chld_handler, NULL); + if (state->sigchld_handler == NULL) { + goto fail_free_handlers; + } + + /* Initialize the printcap cache as soon as the daemon starts. */ + pcap_cache_reload(state->ev, state->msg, reload_pcap_change_notify); + + ok = printing_subsystem_queue_tasks(state); + if (!ok) { + goto fail_free_handlers; + } + + talloc_set_destructor(state, bq_state_destructor); + + return state; + +fail_free_handlers: + TALLOC_FREE(state->sighup_handler); + TALLOC_FREE(state->sigchld_handler); +fail_dereg_printer_drvupgrade: + messaging_deregister(msg_ctx, MSG_PRINTER_DRVUPGRADE, NULL); +fail_dereg_printer_update: + messaging_deregister(msg_ctx, MSG_PRINTER_UPDATE, NULL); +fail_dereg_smb_conf_updated: + messaging_deregister(msg_ctx, MSG_SMB_CONF_UPDATED, state); +fail: + TALLOC_FREE(state); + return NULL; +} + +/**************************************************************************** +main thread of the background lpq updater +****************************************************************************/ +pid_t start_background_queue(struct tevent_context *ev, + struct messaging_context *msg_ctx, + char *logfile) +{ + pid_t pid; + int ret; + ssize_t nread; + char **argv = NULL; + int ready_fds[2]; + + DEBUG(3,("start_background_queue: Starting background LPQ thread\n")); + + ret = pipe(ready_fds); + if (ret == -1) { + return -1; + } + + argv = str_list_make_empty(talloc_tos()); + str_list_add_printf( + &argv, "%s/samba-bgqd", get_dyn_SAMBA_LIBEXECDIR()); + str_list_add_printf( + &argv, "--ready-signal-fd=%d", ready_fds[1]); + str_list_add_printf( + &argv, "--parent-watch-fd=%d", 0); + str_list_add_printf( + &argv, "--debuglevel=%d", debuglevel_get_class(DBGC_RPC_SRV)); + if (!is_default_dyn_CONFIGFILE()) { + str_list_add_printf( + &argv, "--configfile=%s", get_dyn_CONFIGFILE()); + } + if (!is_default_dyn_LOGFILEBASE()) { + str_list_add_printf( + &argv, "--log-basename=%s", get_dyn_LOGFILEBASE()); + } + str_list_add_printf(&argv, "-F"); + if (argv == NULL) { + goto nomem; + } + + ret = posix_spawn(&pid, argv[0], NULL, NULL, argv, environ); + if (ret == -1) { + goto fail; + } + TALLOC_FREE(argv); + + close(ready_fds[1]); + + nread = sys_read(ready_fds[0], &pid, sizeof(pid)); + close(ready_fds[0]); + if (nread != sizeof(pid)) { + goto fail; + } + + return pid; + +nomem: + errno = ENOMEM; +fail: + { + int err = errno; + TALLOC_FREE(argv); + errno = err; + } + + return -1; +} + + +/* Run before the parent forks */ +bool printing_subsystem_init(struct tevent_context *ev_ctx, + struct messaging_context *msg_ctx, + struct dcesrv_context *dce_ctx) +{ + pid_t pid = -1; + + pid = start_background_queue(NULL, NULL, NULL); + if (pid == -1) { + return false; + } + background_lpq_updater_pid = pid; + + if (!print_backend_init(msg_ctx)) { + return false; + } + + return true; +} + +void send_to_bgqd(struct messaging_context *msg_ctx, + uint32_t msg_type, + const uint8_t *buf, + size_t buflen) +{ + pid_t bgqd = pidfile_pid(lp_pid_directory(), "samba-bgqd"); + + if (bgqd == -1) { + return; + } + messaging_send_buf( + msg_ctx, pid_to_procid(bgqd), msg_type, buf, buflen); +} diff --git a/source3/printing/queue_process.h b/source3/printing/queue_process.h new file mode 100644 index 0000000..93bc79f --- /dev/null +++ b/source3/printing/queue_process.h @@ -0,0 +1,44 @@ +/* + Unix SMB/Netbios implementation. + Version 3.0 + printing backend routines + Copyright (C) Andrew Tridgell 1992-2000 + Copyright (C) Jeremy Allison 2002 + Copyright (C) Simo Sorce 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef _SOURCE3_PRINTING_QUEUE_PROCESS_H_ +#define _SOURCE3_PRINTING_QUEUE_PROCESS_H_ + +struct dcesrv_context; + +bool printing_subsystem_init(struct tevent_context *ev_ctx, + struct messaging_context *msg_ctx, + struct dcesrv_context *dce_ctx); +pid_t start_background_queue(struct tevent_context *ev, + struct messaging_context *msg, + char *logfile); +void send_to_bgqd(struct messaging_context *msg_ctx, + uint32_t msg_type, + const uint8_t *buf, + size_t buflen); + +struct bq_state; +struct bq_state *register_printing_bq_handlers( + TALLOC_CTX *mem_ctx, + struct messaging_context *msg_ctx); + +#endif /* _SOURCE3_PRINTING_QUEUE_PROCESS_H_ */ diff --git a/source3/printing/rap_jobid.c b/source3/printing/rap_jobid.c new file mode 100644 index 0000000..7af3d47 --- /dev/null +++ b/source3/printing/rap_jobid.c @@ -0,0 +1,164 @@ +/* + * Maintain rap vs spoolss jobids + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + the printing backend revolves around a tdb database that stores the + SMB view of the print queue + + The key for this database is a jobid - a internally generated number that + uniquely identifies a print job + + reading the print queue involves two steps: + - possibly running lpq and updating the internal database from that + - reading entries from the database + + jobids are assigned when a job starts spooling. +*/ + +#include "rap_jobid.h" +#include +#include "source3/include/util_tdb.h" +#include "lib/util/string_wrappers.h" + +static TDB_CONTEXT *rap_tdb; +static uint16_t next_rap_jobid; +struct rap_jobid_key { + fstring sharename; + uint32_t jobid; +}; + +/*************************************************************************** + Nightmare. LANMAN jobid's are 16 bit numbers..... We must map them to 32 + bit RPC jobids.... JRA. +***************************************************************************/ + +uint16_t pjobid_to_rap(const char* sharename, uint32_t jobid) +{ + uint16_t rap_jobid; + TDB_DATA data, key; + struct rap_jobid_key jinfo; + uint8_t buf[2]; + + DEBUG(10,("pjobid_to_rap: called.\n")); + + if (!rap_tdb) { + /* Create the in-memory tdb. */ + rap_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL, (O_RDWR|O_CREAT), 0644); + if (!rap_tdb) + return 0; + } + + ZERO_STRUCT( jinfo ); + fstrcpy( jinfo.sharename, sharename ); + jinfo.jobid = jobid; + key.dptr = (uint8_t *)&jinfo; + key.dsize = sizeof(jinfo); + + data = tdb_fetch(rap_tdb, key); + if (data.dptr && data.dsize == sizeof(uint16_t)) { + rap_jobid = SVAL(data.dptr, 0); + SAFE_FREE(data.dptr); + DEBUG(10,("pjobid_to_rap: jobid %u maps to RAP jobid %u\n", + (unsigned int)jobid, (unsigned int)rap_jobid)); + return rap_jobid; + } + SAFE_FREE(data.dptr); + /* Not found - create and store mapping. */ + rap_jobid = ++next_rap_jobid; + if (rap_jobid == 0) + rap_jobid = ++next_rap_jobid; + SSVAL(buf,0,rap_jobid); + data.dptr = buf; + data.dsize = sizeof(rap_jobid); + tdb_store(rap_tdb, key, data, TDB_REPLACE); + tdb_store(rap_tdb, data, key, TDB_REPLACE); + + DEBUG(10,("pjobid_to_rap: created jobid %u maps to RAP jobid %u\n", + (unsigned int)jobid, (unsigned int)rap_jobid)); + return rap_jobid; +} + +bool rap_to_pjobid(uint16_t rap_jobid, fstring sharename, uint32_t *pjobid) +{ + TDB_DATA data, key; + uint8_t buf[2]; + + DEBUG(10,("rap_to_pjobid called.\n")); + + if (!rap_tdb) + return False; + + SSVAL(buf,0,rap_jobid); + key.dptr = buf; + key.dsize = sizeof(rap_jobid); + data = tdb_fetch(rap_tdb, key); + if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) ) + { + struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr; + if (sharename != NULL) { + fstrcpy( sharename, jinfo->sharename ); + } + *pjobid = jinfo->jobid; + DEBUG(10,("rap_to_pjobid: jobid %u maps to RAP jobid %u\n", + (unsigned int)*pjobid, (unsigned int)rap_jobid)); + SAFE_FREE(data.dptr); + return True; + } + + DEBUG(10,("rap_to_pjobid: Failed to lookup RAP jobid %u\n", + (unsigned int)rap_jobid)); + SAFE_FREE(data.dptr); + return False; +} + +void rap_jobid_delete(const char* sharename, uint32_t jobid) +{ + TDB_DATA key, data; + uint16_t rap_jobid; + struct rap_jobid_key jinfo; + uint8_t buf[2]; + + DEBUG(10,("rap_jobid_delete: called.\n")); + + if (!rap_tdb) + return; + + ZERO_STRUCT( jinfo ); + fstrcpy( jinfo.sharename, sharename ); + jinfo.jobid = jobid; + key.dptr = (uint8_t *)&jinfo; + key.dsize = sizeof(jinfo); + + data = tdb_fetch(rap_tdb, key); + if (!data.dptr || (data.dsize != sizeof(uint16_t))) { + DEBUG(10,("rap_jobid_delete: cannot find jobid %u\n", + (unsigned int)jobid )); + SAFE_FREE(data.dptr); + return; + } + + DEBUG(10,("rap_jobid_delete: deleting jobid %u\n", + (unsigned int)jobid )); + + rap_jobid = SVAL(data.dptr, 0); + SAFE_FREE(data.dptr); + SSVAL(buf,0,rap_jobid); + data.dptr = buf; + data.dsize = sizeof(rap_jobid); + tdb_delete(rap_tdb, key); + tdb_delete(rap_tdb, data); +} diff --git a/source3/printing/rap_jobid.h b/source3/printing/rap_jobid.h new file mode 100644 index 0000000..6325689 --- /dev/null +++ b/source3/printing/rap_jobid.h @@ -0,0 +1,29 @@ +/* + * Maintain rap vs spoolss jobids + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + + +#ifndef __PRINTING_RAP_JOBID_H__ +#define __PRINTING_RAP_JOBID_H__ + +#include "includes.h" + +uint16_t pjobid_to_rap(const char *sharename, uint32_t jobid); +bool rap_to_pjobid( + uint16_t rap_jobid, fstring sharename, uint32_t *pjobid); +void rap_jobid_delete(const char *sharename, uint32_t jobid); + +#endif diff --git a/source3/printing/samba-bgqd.c b/source3/printing/samba-bgqd.c new file mode 100644 index 0000000..59ed0cc --- /dev/null +++ b/source3/printing/samba-bgqd.c @@ -0,0 +1,359 @@ +/* + * Printing background queue helper + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "replace.h" +#include "system/filesys.h" +#include "lib/util/server_id.h" +#include "source3/locking/share_mode_lock.h" +#include "source3/param/loadparm.h" +#include "source3/param/param_proto.h" +#include "lib/cmdline/cmdline.h" +#include "lib/cmdline/closefrom_except.h" +#include "lib/util/talloc_stack.h" +#include "lib/util/debug.h" +#include "lib/util/signal.h" +#include "lib/util/fault.h" +#include "lib/util/become_daemon.h" +#include "lib/util/charset/charset.h" +#include "lib/util/samba_util.h" +#include "lib/util/sys_rw.h" +#include "lib/util/pidfile.h" +#include "lib/async_req/async_sock.h" +#include "dynconfig/dynconfig.h" +#include "source3/lib/global_contexts.h" +#include "messages.h" +#include "nsswitch/winbind_client.h" +#include "source3/include/auth.h" +#include "source3/lib/util_procid.h" +#include "source3/auth/proto.h" +#include "source3/printing/queue_process.h" +#include "source3/lib/substitute.h" + +static void watch_handler(struct tevent_req *req) +{ + bool *pdone = tevent_req_callback_data_void(req); + *pdone = true; +} + +static void bgqd_sig_term_handler( + struct tevent_context *ev, + struct tevent_signal *se, + int signum, + int count, + void *siginfo, + void *private_data) +{ + bool *pdone = private_data; + *pdone = true; +} + +static bool ready_signal_filter( + struct messaging_rec *rec, void *private_data) +{ + pid_t pid = getpid(); + ssize_t written; + + if (rec->msg_type != MSG_DAEMON_READY_FD) { + return false; + } + if (rec->num_fds != 1) { + return false; + } + + written = sys_write(rec->fds[0], &pid, sizeof(pid)); + if (written != sizeof(pid)) { + DBG_ERR("Could not write pid: %s\n", strerror(errno)); + } + + return false; +} + +static int samba_bgqd_pidfile_create( + struct messaging_context *msg_ctx, + const char *progname, + int ready_signal_fd) +{ + const char *piddir = lp_pid_directory(); + size_t len = strlen(piddir) + strlen(progname) + 6; + char pidFile[len]; + pid_t existing_pid; + int fd, ret; + + snprintf(pidFile, + sizeof(pidFile), + "%s/%s.pid", + piddir, progname); + + ret = pidfile_path_create(pidFile, &fd, &existing_pid); + if (ret == 0) { + struct tevent_req *ready_signal_req = NULL; + + /* + * Listen for fd's sent via MSG_DAEMON_READY_FD: + * Multiple instances of this process might have raced + * for creating the pidfile. Make sure the parent does + * not suffer from this race, reply on behalf of the + * loser of this race. + */ + + ready_signal_req = messaging_filtered_read_send( + msg_ctx, + messaging_tevent_context(msg_ctx), + msg_ctx, + ready_signal_filter, + NULL); + if (ready_signal_req == NULL) { + DBG_DEBUG("messaging_filtered_read_send failed\n"); + pidfile_unlink(piddir, progname); + pidfile_fd_close(fd); + return ENOMEM; + } + + /* leak fd */ + return 0; + } + + if (ret != EAGAIN) { + DBG_DEBUG("pidfile_path_create() failed: %s\n", + strerror(ret)); + return ret; + } + + DBG_DEBUG("%s pid %d exists\n", progname, (int)existing_pid); + + if (ready_signal_fd != -1) { + /* + * We lost the race for the pidfile, but someone else + * can report readiness on our behalf. + */ + NTSTATUS status = messaging_send_iov( + msg_ctx, + pid_to_procid(existing_pid), + MSG_DAEMON_READY_FD, + NULL, + 0, + &ready_signal_fd, + 1); + if (!NT_STATUS_IS_OK(status)) { + DBG_DEBUG("Could not send ready_signal_fd: %s\n", + nt_errstr(status)); + } + } + + return EAGAIN; +} + +int main(int argc, const char *argv[]) +{ + struct samba_cmdline_daemon_cfg *cmdline_daemon_cfg = NULL; + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + const char *progname = getprogname(); + TALLOC_CTX *frame = NULL; + poptContext pc; + struct messaging_context *msg_ctx = NULL; + struct tevent_context *ev = NULL; + struct tevent_req *watch_req = NULL; + struct tevent_signal *sigterm_handler = NULL; + struct bq_state *bq = NULL; + int log_stdout = 0; + int ready_signal_fd = -1; + int watch_fd = -1; + NTSTATUS status; + int ret; + bool ok; + bool done = false; + int exitcode = 1; + + struct poptOption long_options[] = { + POPT_AUTOHELP + POPT_COMMON_SAMBA + POPT_COMMON_DAEMON + + /* + * File descriptor to write the PID of the helper + * process to + */ + { + .longName = "ready-signal-fd", + .argInfo = POPT_ARG_INT, + .arg = &ready_signal_fd, + .descrip = "Fd to signal readiness to" , + }, + + /* + * Read end of a pipe held open by the parent + * smbd. Exit this process when it becomes readable. + */ + { + .longName = "parent-watch-fd", + .argInfo = POPT_ARG_INT, + .arg = &watch_fd, + .descrip = "Fd to watch for exiting", + }, + POPT_TABLEEND + }; + + { + const char *fd_params[] = { + "ready-signal-fd", "parent-watch-fd", + }; + + closefrom_except_fd_params( + 3, ARRAY_SIZE(fd_params), fd_params, argc, argv); + } + + talloc_enable_null_tracking(); + frame = talloc_stackframe(); + umask(0); + set_remote_machine_name("smbd-bgqd", true); + + ok = samba_cmdline_init(frame, + SAMBA_CMDLINE_CONFIG_SERVER, + true /* require_smbconf */); + if (!ok) { + DBG_ERR("Failed to setup cmdline parser!\n"); + exit(ENOMEM); + } + + cmdline_daemon_cfg = samba_cmdline_get_daemon_cfg(); + + pc = samba_popt_get_context(progname, + argc, + argv, + long_options, + 0); + if (pc == NULL) { + DBG_ERR("Failed to get popt context!\n"); + exit(ENOMEM); + } + + ret = poptGetNextOpt(pc); + if (ret < -1) { + fprintf(stderr, "invalid options: %s\n", poptStrerror(ret)); + goto done; + } + + poptFreeContext(pc); + + log_stdout = (debug_get_log_type() == DEBUG_STDOUT); + + /* main process will notify systemd */ + daemon_sd_notifications(false); + + if (!cmdline_daemon_cfg->fork) { + daemon_status(progname, "Starting process ... "); + } else { + become_daemon(true, + cmdline_daemon_cfg->no_process_group, + log_stdout); + } + + BlockSignals(true, SIGPIPE); + + smb_init_locale(); + dump_core_setup(progname, lp_logfile(frame, lp_sub)); + + msg_ctx = global_messaging_context(); + if (msg_ctx == NULL) { + DBG_ERR("messaging_init() failed\n"); + goto done; + } + ev = messaging_tevent_context(msg_ctx); + + ret = samba_bgqd_pidfile_create(msg_ctx, progname, ready_signal_fd); + if (ret != 0) { + goto done; + } + + if (watch_fd != -1) { + watch_req = wait_for_read_send(ev, ev, watch_fd, true); + if (watch_req == NULL) { + fprintf(stderr, "tevent_add_fd failed\n"); + goto done; + } + tevent_req_set_callback(watch_req, watch_handler, &done); + } + + (void)winbind_off(); + ok = init_guest_session_info(frame); + (void)winbind_on(); + if (!ok) { + DBG_ERR("init_guest_session_info failed\n"); + goto done; + } + + (void)winbind_off(); + status = init_system_session_info(frame); + (void)winbind_on(); + if (!NT_STATUS_IS_OK(status)) { + DBG_ERR("init_system_session_info failed: %s\n", + nt_errstr(status)); + goto done; + } + + sigterm_handler = tevent_add_signal( + ev, frame, SIGTERM, 0, bgqd_sig_term_handler, &done); + if (sigterm_handler == NULL) { + DBG_ERR("Could not install SIGTERM handler\n"); + goto done; + } + + bq = register_printing_bq_handlers(frame, msg_ctx); + if (bq == NULL) { + DBG_ERR("Could not register bq handlers\n"); + goto done; + } + + ok = locking_init(); + if (!ok) { + DBG_ERR("locking_init failed\n"); + goto done; + } + + if (ready_signal_fd != -1) { + pid_t pid = getpid(); + ssize_t written; + + written = sys_write(ready_signal_fd, &pid, sizeof(pid)); + if (written != sizeof(pid)) { + DBG_ERR("Reporting readiness failed\n"); + goto done; + } + close(ready_signal_fd); + ready_signal_fd = -1; + } + + while (!done) { + TALLOC_CTX *tmp = talloc_stackframe(); + ret = tevent_loop_once(ev); + TALLOC_FREE(tmp); + if (ret != 0) { + DBG_ERR("tevent_loop_once failed\n"); + break; + } + } + + exitcode = 0; +done: + TALLOC_FREE(watch_req); + TALLOC_FREE(bq); + TALLOC_FREE(sigterm_handler); + global_messaging_context_free(); + TALLOC_FREE(frame); + return exitcode; +} diff --git a/source3/printing/tests/README.vlp b/source3/printing/tests/README.vlp new file mode 100644 index 0000000..fc0b91a --- /dev/null +++ b/source3/printing/tests/README.vlp @@ -0,0 +1,19 @@ +Virtual line printer test program (vlp) +======================================= + +This can be useful for testing/debugging Samba print code. It gives you a +virtual full-function printer. + +Setup + +Set up Samba to use vlp. + In your smb.conf file under [global], add the following option: + printing = vlp + and then add any number of print shares, without needing to make them + really exist. + + [testprinter] + printable = yes + + is all you need for the most basic virtual printer. + diff --git a/source3/printing/tests/vlp.c b/source3/printing/tests/vlp.c new file mode 100644 index 0000000..b19b21e --- /dev/null +++ b/source3/printing/tests/vlp.c @@ -0,0 +1,445 @@ +/* + Unix SMB/Netbios implementation. + + Virtual lp system for printer testing + + Copyright (C) Tim Potter 2000 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/passwd.h" +#include "system/filesys.h" +#include "printing.h" +#include "util_tdb.h" + +#ifdef malloc +#undef malloc +#endif + +#define PRINT_FIRSTJOB 100 + +static TDB_CONTEXT *tdb; + +struct vlp_job { + fstring owner; + int jobid; + fstring jobname; + int size; + int status; + time_t submit_time; + int deleted; +}; + +/* Print usage */ + +static void usage(void) +{ + printf("Usage: vlp tdbfile=/tmp/vlp.tdb lpq|lprm|print|queuepause|queueresume|" + "lppause|lpresume [args]\n"); +} + +/* Return an array of vlp jobs that is the printer queue */ + +static void get_job_list(char *printer, struct vlp_job **job_list, + int *num_jobs) +{ + fstring keystr; + TDB_DATA data; + + slprintf(keystr, sizeof(keystr) - 1, "LPQ/%s", printer); + data = tdb_fetch_bystring(tdb, keystr); + + *job_list = (struct vlp_job *)data.dptr; + *num_jobs = data.dsize / sizeof(struct vlp_job); +} + +/* Store an array of vl jobs for the queue */ + +static void set_job_list(char *printer, struct vlp_job *job_list, + int num_jobs) +{ + fstring keystr; + TDB_DATA data; + + slprintf(keystr, sizeof(keystr) - 1, "LPQ/%s", printer); + + data.dptr = (unsigned char *)job_list; + data.dsize = num_jobs * sizeof(struct vlp_job); + tdb_store_bystring(tdb, keystr, data, TDB_REPLACE); +} + +/* Return the next job number for a printer */ + +static int next_jobnum(char *printer) +{ + fstring keystr; + int jobnum; + + slprintf(keystr, sizeof(keystr) - 1, "JOBNUM/%s", printer); + + tdb_lock_bystring(tdb, keystr); + + jobnum = tdb_fetch_int32(tdb, keystr); + + /* Create next job index if none exists */ + + if (jobnum == -1) { + jobnum = PRINT_FIRSTJOB; + } else { + jobnum++; + } + + tdb_store_int32(tdb, keystr, jobnum); + + tdb_unlock_bystring(tdb, keystr); + + return jobnum; +} + +static void set_printer_status(char *printer, int status) +{ + fstring keystr; + + slprintf(keystr, sizeof(keystr) - 1, "STATUS/%s", printer); + tdb_store_int32(tdb, keystr, status); +} + +static int get_printer_status(char *printer) +{ + fstring keystr; + TDB_DATA data; + + slprintf(keystr, sizeof(keystr) - 1, "STATUS/%s", printer); + + data.dptr = (unsigned char *)keystr; + data.dsize = strlen(keystr) + 1; + + if (!tdb_exists(tdb, data)) { + set_printer_status(printer, LPSTAT_OK); + return LPSTAT_OK; + } + + return tdb_fetch_int32(tdb, keystr); +} + +/* Display printer queue */ + +static int lpq_command(int argc, char **argv) +{ + char *printer; + struct vlp_job *job_list = NULL; + int i, num_jobs; + + if (argc != 2) { + printf("Usage: lpq \n"); + return 1; + } + + printer = argv[1]; + + /* Display printer status */ + + switch (get_printer_status(printer)) { + case LPSTAT_OK: + printf("enabled\n"); + break; + case LPSTAT_STOPPED: + printf("disabled\n"); + break; + case LPSTAT_ERROR: + default: + printf("error\n"); + break; + } + + /* Print queued documents */ + + get_job_list(printer, &job_list, &num_jobs); + + for (i = 0; i < num_jobs; i++) { + if (job_list[i].deleted) continue; + printf("%d\t%d\t%d\t%ld\t%s\t%s\n", job_list[i].jobid, + job_list[i].size, + (i == 0 && job_list[i].status == LPQ_QUEUED) ? + LPQ_SPOOLING : job_list[i].status, + (long int)job_list[i].submit_time, job_list[i].owner, + job_list[i].jobname); + } + + free(job_list); + + return 0; +} + +/* Remove a job */ + +static int lprm_command(int argc, char **argv) +{ + char *printer; + int jobid, num_jobs, i; + struct vlp_job *job_list; + + if (argc < 3) { + printf("Usage: lprm \n"); + return 1; + } + + printer = argv[1]; + jobid = atoi(argv[2]); + + get_job_list(printer, &job_list, &num_jobs); + + for (i = 0; i < num_jobs; i++) { + if (job_list[i].jobid == jobid) { + job_list[i].deleted = 1; + set_job_list(printer, job_list, num_jobs); + break; + } + } + + return 0; +} + +/* print command = print-test %p %s */ + +static int print_command(int argc, char **argv) +{ + char *printer; + fstring keystr; + struct passwd *pw; + TDB_DATA value, queue; + struct vlp_job job; + + if (argc < 3) { + printf("Usage: print \n"); + return 1; + } + + printer = argv[1]; + + ZERO_STRUCT(job); + + /* Create a job record */ + + slprintf(job.jobname, sizeof(job.jobname) - 1, "%s", argv[2]); + + if (!(pw = getpwuid(geteuid()))) { + printf("getpwuid failed\n"); + return 1; + } + + slprintf(job.owner, sizeof(job.owner) - 1, "%s", pw->pw_name); + + job.jobid = next_jobnum(printer); + job.size = 666; + job.submit_time = time(NULL); + + /* Store job entry in queue */ + + slprintf(keystr, sizeof(keystr) - 1, "LPQ/%s", printer); + + value = tdb_fetch_bystring(tdb, keystr); + + if (value.dptr) { + + /* Add job to end of queue */ + + queue.dptr = (unsigned char *)malloc(value.dsize + sizeof(struct vlp_job)); + if (!queue.dptr) return 1; + + memcpy(queue.dptr, value.dptr, value.dsize); + memcpy(queue.dptr + value.dsize, &job, sizeof(struct vlp_job)); + + queue.dsize = value.dsize + sizeof(struct vlp_job); + + tdb_store_bystring(tdb, keystr, queue, TDB_REPLACE); + + free(queue.dptr); + + } else { + + /* Create new queue */ + queue.dptr = (unsigned char *)&job; + queue.dsize = sizeof(struct vlp_job); + + tdb_store_bystring(tdb, keystr, queue, TDB_REPLACE); + } + + return 0; +} + +/* Pause the queue */ + +static int queuepause_command(int argc, char **argv) +{ + char *printer; + + if (argc != 2) { + printf("Usage: queuepause \n"); + return 1; + } + + printer = argv[1]; + set_printer_status(printer, LPSTAT_STOPPED); + + return 0; +} + +/* Resume the queue */ + +static int queueresume_command(int argc, char **argv) +{ + char *printer; + + if (argc != 2) { + printf("Usage: queueresume \n"); + return 1; + } + + printer = argv[1]; + set_printer_status(printer, LPSTAT_OK); + + return 0; +} + +/* Pause a job */ + +static int lppause_command(int argc, char **argv) +{ + struct vlp_job *job_list; + char *printer; + int jobid, num_jobs, i; + + if (argc != 3) { + printf("Usage: lppause \n"); + return 1; + } + + printer = argv[1]; + jobid = atoi(argv[2]); + + get_job_list(printer, &job_list, &num_jobs); + + for (i = 0; i < num_jobs; i++) { + if (job_list[i].jobid == jobid) { + job_list[i].status = LPQ_PAUSED; + set_job_list(printer, job_list, num_jobs); + return 0; + } + } + + return 1; +} + +/* Resume a job */ + +static int lpresume_command(int argc, char **argv) +{ + struct vlp_job *job_list; + char *printer; + int jobid, num_jobs, i; + + if (argc != 3) { + printf("Usage: lpresume \n"); + return 1; + } + + printer = argv[1]; + jobid = atoi(argv[2]); + + get_job_list(printer, &job_list, &num_jobs); + + for (i = 0; i < num_jobs; i++) { + if (job_list[i].jobid == jobid) { + job_list[i].status = LPQ_QUEUED; + set_job_list(printer, job_list, num_jobs); + return 0; + } + } + + return 1; +} + +int main(int argc, char **argv) +{ + /* Parameter check */ + const char *printdb_path = NULL; + + if (argc < 2) { + usage(); + return 1; + } + + if (strncmp(argv[1], "tdbfile", strlen("tdbfile")) != 0) { + usage(); + return 1; + } + + printdb_path = get_string_param(argv[1]); + if (!printdb_path) { + return 1; + } + + /* FIXME: We should *never* open a tdb without logging! */ + if (!(tdb = tdb_open(printdb_path, 0, 0, O_RDWR | O_CREAT, + 0666))) { + printf("%s: unable to open %s\n", argv[0], printdb_path); + return 1; + } + + /* Ensure we are modes 666 */ + + chmod(printdb_path, 0666); + + /* Do commands */ + if (argc < 3) { + usage(); + return 1; + } + + if (strcmp(argv[2], "lpq") == 0) { + return lpq_command(argc - 2, &argv[2]); + } + + if (strcmp(argv[2], "lprm") == 0) { + return lprm_command(argc - 2, &argv[2]); + } + + if (strcmp(argv[2], "print") == 0) { + return print_command(argc - 2, &argv[2]); + } + + if (strcmp(argv[2], "queuepause") == 0) { + return queuepause_command(argc - 2, &argv[2]); + } + + if (strcmp(argv[2], "queueresume") == 0) { + return queueresume_command(argc - 2, &argv[2]); + } + + if (strcmp(argv[2], "lppause") == 0) { + return lppause_command(argc - 2, &argv[2]); + } + + if (strcmp(argv[2], "lpresume") == 0) { + return lpresume_command(argc - 2, &argv[2]); + } + + /* Unknown command */ + + printf("%s: invalid command %s\n", argv[0], argv[1]); + return 1; +} -- cgit v1.2.3