?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This commit was manufactured by cvs2svn to create branch 'SAMBA_2_2'.
[Samba.git] / source / printing / nt_printing.c
blob91679235cd70f6a09e5372f090d635a1bf6cdd73
1 #define OLD_NTDOMAIN 1
2 /*
3 * Unix SMB/Netbios implementation.
4 * Version 1.9.
5 * RPC Pipe client / server routines
6 * Copyright (C) Andrew Tridgell 1992-2000,
7 * Copyright (C) Jean François Micouleau 1998-2000.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25
26 extern int DEBUGLEVEL;
27 extern pstring global_myname;
28 extern DOM_SID global_sid_World;
29
30 static TDB_CONTEXT *tdb; /* used for driver files */
31
32 #define FORMS_PREFIX "FORMS/"
33 #define DRIVERS_PREFIX "DRIVERS/"
34 #define PRINTERS_PREFIX "PRINTERS/"
35
36 #define DATABASE_VERSION 1
37
38 /* We need one default form to support our default printer. Msoft adds the
39 forms it wants and in the ORDER it wants them (note: DEVMODE papersize is an
40 array index). Letter is always first, so (for the current code) additions
41 always put things in the correct order. */
42 static nt_forms_struct default_forms[] = {
43 {"Letter", 0x2, 0x34b5b, 0x44367, 0x0, 0x0, 0x34b5b, 0x44367},
44 };
45
46
47 /****************************************************************************
48 open the NT printing tdb
49 ****************************************************************************/
50 BOOL nt_printing_init(void)
51 {
52 static pid_t local_pid;
53 char *vstring = "INFO/version";
54
55 if (tdb && local_pid == sys_getpid()) return True;
56 tdb = tdb_open(lock_path("ntdrivers.tdb"), 0, 0, O_RDWR|O_CREAT, 0600);
57 if (!tdb) {
58 DEBUG(0,("Failed to open nt drivers database\n"));
59 return False;
60 }
61
62 local_pid = sys_getpid();
63
64 /* handle a Samba upgrade */
65 tdb_lock_bystring(tdb, vstring);
66 if (tdb_fetch_int(tdb, vstring) != DATABASE_VERSION) {
67 tdb_traverse(tdb, (tdb_traverse_func)tdb_delete, NULL);
68 tdb_store_int(tdb, vstring, DATABASE_VERSION);
69 }
70 tdb_unlock_bystring(tdb, vstring);
71
72 return True;
73 }
74
75
76 /****************************************************************************
77 get a form struct list
78 ****************************************************************************/
79 int get_ntforms(nt_forms_struct **list)
80 {
81 TDB_DATA kbuf, newkey, dbuf;
82 nt_forms_struct form;
83 int ret;
84 int i;
85 int n = 0;
86
87 for (kbuf = tdb_firstkey(tdb);
88 kbuf.dptr;
89 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
90 if (strncmp(kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0) continue;
91
92 dbuf = tdb_fetch(tdb, kbuf);
93 if (!dbuf.dptr) continue;
94
95 fstrcpy(form.name, kbuf.dptr+strlen(FORMS_PREFIX));
96 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddddddd",
97 &i, &form.flag, &form.width, &form.length, &form.left,
98 &form.top, &form.right, &form.bottom);
99 safe_free(dbuf.dptr);
100 if (ret != dbuf.dsize) continue;
101
102 /* allocate space and populate the list in correct order */
103 if (i+1 > n) {
104 *list = Realloc(*list, sizeof(nt_forms_struct)*(i+1));
105 n = i+1;
106 }
107 (*list)[i] = form;
108 }
109
110 /* we should never return a null forms list or NT gets unhappy */
111 if (n == 0) {
112 *list = (nt_forms_struct *)memdup(&default_forms[0], sizeof(default_forms));
113 n = sizeof(default_forms) / sizeof(default_forms[0]);
114 }
115
116
117 return n;
118 }
119
120 /****************************************************************************
121 write a form struct list
122 ****************************************************************************/
123 int write_ntforms(nt_forms_struct **list, int number)
124 {
125 pstring buf, key;
126 int len;
127 TDB_DATA kbuf,dbuf;
128 int i;
129
130 for (i=0;i<number;i++) {
131 /* save index, so list is rebuilt in correct order */
132 len = tdb_pack(buf, sizeof(buf), "dddddddd",
133 i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
134 (*list)[i].left, (*list)[i].top, (*list)[i].right,
135 (*list)[i].bottom);
136 if (len > sizeof(buf)) break;
137 slprintf(key, sizeof(key), "%s%s", FORMS_PREFIX, (*list)[i].name);
138 kbuf.dsize = strlen(key)+1;
139 kbuf.dptr = key;
140 dbuf.dsize = len;
141 dbuf.dptr = buf;
142 if (tdb_store(tdb, kbuf, dbuf, TDB_REPLACE) != 0) break;
143 }
144
145 return i;
146 }
147
148 /****************************************************************************
149 add a form struct at the end of the list
150 ****************************************************************************/
151 BOOL add_a_form(nt_forms_struct **list, const FORM *form, int *count)
152 {
153 int n=0;
154 BOOL update;
155 fstring form_name;
156
157 /*
158 * NT tries to add forms even when
159 * they are already in the base
160 * only update the values if already present
161 */
162
163 update=False;
164
165 unistr2_to_ascii(form_name, &form->name, sizeof(form_name)-1);
166 for (n=0; n<*count; n++) {
167 if (!strncmp((*list)[n].name, form_name, strlen(form_name))) {
168 DEBUG(103, ("NT workaround, [%s] already exists\n", form_name));
169 update=True;
170 break;
171 }
172 }
173
174 if (update==False) {
175 if((*list=Realloc(*list, (n+1)*sizeof(nt_forms_struct))) == NULL)
176 return False;
177 unistr2_to_ascii((*list)[n].name, &form->name, sizeof((*list)[n].name)-1);
178 (*count)++;
179 }
180
181 (*list)[n].flag=form->flags;
182 (*list)[n].width=form->size_x;
183 (*list)[n].length=form->size_y;
184 (*list)[n].left=form->left;
185 (*list)[n].top=form->top;
186 (*list)[n].right=form->right;
187 (*list)[n].bottom=form->bottom;
188
189 return True;
190 }
191
192 /****************************************************************************
193 delete a named form struct
194 ****************************************************************************/
195 BOOL delete_a_form(nt_forms_struct **list, UNISTR2 *del_name, int *count, uint32 *ret)
196 {
197 pstring key;
198 TDB_DATA kbuf;
199 int n=0;
200 fstring form_name;
201
202 *ret = 0;
203
204 if (*count == 1) {
205 /*
206 * Don't delete the last form (no empty lists).
207 * CHECKME ! Is this correct ? JRA.
208 */
209 *ret = ERROR_INVALID_PARAMETER;
210 return False;
211 }
212
213 unistr2_to_ascii(form_name, del_name, sizeof(form_name)-1);
214
215 for (n=0; n<*count; n++) {
216 if (!strncmp((*list)[n].name, form_name, strlen(form_name))) {
217 DEBUG(103, ("delete_a_form, [%s] in list\n", form_name));
218 break;
219 }
220 }
221
222 if (n == *count) {
223 DEBUG(10,("delete_a_form, [%s] not found\n", form_name));
224 *ret = ERROR_INVALID_PARAMETER;
225 return False;
226 }
227
228 slprintf(key, sizeof(key), "%s%s", FORMS_PREFIX, (*list)[n].name);
229 kbuf.dsize = strlen(key)+1;
230 kbuf.dptr = key;
231 if (tdb_delete(tdb, kbuf) != 0) {
232 *ret = ERROR_NOT_ENOUGH_MEMORY;
233 return False;
234 }
235
236 return True;
237 }
238
239 /****************************************************************************
240 update a form struct
241 ****************************************************************************/
242 void update_a_form(nt_forms_struct **list, const FORM *form, int count)
243 {
244 int n=0;
245 fstring form_name;
246 unistr2_to_ascii(form_name, &(form->name), sizeof(form_name)-1);
247
248 DEBUG(106, ("[%s]\n", form_name));
249 for (n=0; n<count; n++)
250 {
251 DEBUGADD(106, ("n [%d]:[%s]\n", n, (*list)[n].name));
252 if (!strncmp((*list)[n].name, form_name, strlen(form_name)))
253 break;
254 }
255
256 if (n==count) return;
257
258 (*list)[n].flag=form->flags;
259 (*list)[n].width=form->size_x;
260 (*list)[n].length=form->size_y;
261 (*list)[n].left=form->left;
262 (*list)[n].top=form->top;
263 (*list)[n].right=form->right;
264 (*list)[n].bottom=form->bottom;
265 }
266
267 /****************************************************************************
268 get the nt drivers list
269
270 traverse the database and look-up the matching names
271 ****************************************************************************/
272 int get_ntdrivers(fstring **list, char *architecture, uint32 version)
273 {
274 int total=0;
275 fstring short_archi;
276 pstring key;
277 TDB_DATA kbuf, newkey;
278
279 get_short_archi(short_archi, architecture);
280 slprintf(key, sizeof(key), "%s%s/%d/", DRIVERS_PREFIX, short_archi, version);
281
282 for (kbuf = tdb_firstkey(tdb);
283 kbuf.dptr;
284 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
285 if (strncmp(kbuf.dptr, key, strlen(key)) != 0) continue;
286
287 if((*list = Realloc(*list, sizeof(fstring)*(total+1))) == NULL)
288 return -1;
289
290 fstrcpy((*list)[total], kbuf.dptr+strlen(key));
291 total++;
292 }
293
294 return(total);
295 }
296
297 /****************************************************************************
298 function to do the mapping between the long architecture name and
299 the short one.
300 ****************************************************************************/
301 BOOL get_short_archi(char *short_archi, char *long_archi)
302 {
303 struct table {
304 char *long_archi;
305 char *short_archi;
306 };
307
308 struct table archi_table[]=
309 {
310 {"Windows 4.0", "WIN40" },
311 {"Windows NT x86", "W32X86" },
312 {"Windows NT R4000", "W32MIPS" },
313 {"Windows NT Alpha_AXP", "W32ALPHA" },
314 {"Windows NT PowerPC", "W32PPC" },
315 {NULL, "" }
316 };
317
318 int i=-1;
319
320 DEBUG(107,("Getting architecture dependant directory\n"));
321 do {
322 i++;
323 } while ( (archi_table[i].long_archi!=NULL ) &&
324 StrCaseCmp(long_archi, archi_table[i].long_archi) );
325
326 if (archi_table[i].long_archi==NULL) {
327 DEBUGADD(107,("Unknown architecture [%s] !\n", long_archi));
328 return FALSE;
329 }
330
331 StrnCpy (short_archi, archi_table[i].short_archi, strlen(archi_table[i].short_archi));
332
333 DEBUGADD(108,("index: [%d]\n", i));
334 DEBUGADD(108,("long architecture: [%s]\n", long_archi));
335 DEBUGADD(108,("short architecture: [%s]\n", short_archi));
336
337 return TRUE;
338 }
339
340 /****************************************************************************
341 Determine the correct cVersion associated with an architecture and driver
342 ****************************************************************************/
343 static uint32 get_correct_cversion(fstring architecture, fstring driverpath_in,
344 struct current_user *user, uint32 *perr)
345 {
346 int cversion;
347 int access_mode;
348 int action;
349 int ecode;
350 char buf[PE_HEADER_SIZE];
351 ssize_t byte_count;
352 pstring driverpath;
353 fstring user_name;
354 fstring null_pw;
355 files_struct *fsp = NULL;
356 BOOL bad_path;
357 SMB_STRUCT_STAT st;
358 struct passwd *pass;
359 connection_struct *conn;
360
361 ZERO_STRUCT(st);
362
363 /* If architecture is Windows 95/98, the version is always 0. */
364 if (strcmp(architecture, "WIN40") == 0) {
365 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
366 return 0;
367 }
368
369 become_root();
370 pass = getpwuid(user->uid);
371 if(pass == NULL) {
372 DEBUG(0,("get_correct_cversion: Unable to get passwd entry for uid %u\n",
373 (unsigned int)user->uid ));
374 unbecome_root();
375 *perr = ERROR_ACCESS_DENIED;
376 return -1;
377 }
378 unbecome_root();
379
380 /* connect to the print$ share under the same account as the user connected
381 * to the rpc pipe */
382 fstrcpy(user_name, pass->pw_name );
383 DEBUG(10,("get_correct_cversion: uid %d -> user %s\n", (int)user->uid, user_name));
384
385 /* Null password is ok - we are already an authenticated user... */
386 *null_pw = '\0';
387 conn = make_connection("print$", user_name, null_pw, 0, "A:", user->vuid, &ecode);
388
389 if (conn == NULL) {
390 DEBUG(0,("get_correct_cversion: Unable to connect\n"));
391 *perr = (uint32)ecode;
392 return -1;
393 }
394
395 /* Save who we are - we are temporarily becoming the connection user. */
396 push_sec_ctx();
397
398 if (!become_user(conn, conn->vuid)) {
399 DEBUG(0,("get_correct_cversion: Can't become user %s\n", user_name ));
400 *perr = ERROR_ACCESS_DENIED;
401 pop_sec_ctx();
402 return -1;
403 }
404
405 /* Open the driver file (Portable Executable format) and determine the
406 * deriver the cversion. */
407 slprintf(driverpath, sizeof(driverpath), "%s/%s", architecture, driverpath_in);
408
409 unix_convert(driverpath,conn,NULL,&bad_path,&st);
410
411 fsp = open_file_shared(conn, driverpath, &st,
412 SET_OPEN_MODE(DOS_OPEN_RDONLY),
413 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
414 0, 0, &access_mode, &action);
415 if (!fsp) {
416 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
417 driverpath, errno));
418 *perr = ERROR_ACCESS_DENIED;
419 goto error_exit;
420 }
421
422 if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
423 DEBUG(3,("get_correct_cversion: File [%s] DOS header too short, bytes read = %d\n",
424 driverpath, byte_count));
425 *perr = NT_STATUS_FILE_INVALID;
426 goto error_exit;
427 }
428
429 /* Is this really a DOS header? */
430 if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
431 DEBUG(6,("get_correct_cversion: File [%s] bad DOS magic = 0x%x\n",
432 driverpath, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
433 *perr = NT_STATUS_FILE_INVALID;
434 goto error_exit;
435 }
436
437 /* Skip OEM header (if any) and the DOS stub to start of Windows header */
438 if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
439 DEBUG(3,("get_correct_cversion: File [%s] too short, errno = %d\n",
440 driverpath, errno));
441 *perr = NT_STATUS_FILE_INVALID;
442 goto error_exit;
443 }
444
445 if ((byte_count = vfs_read_data(fsp, buf, PE_HEADER_SIZE)) < PE_HEADER_SIZE) {
446 DEBUG(3,("get_correct_cversion: File [%s] Windows header too short, bytes read = %d\n",
447 driverpath, byte_count));
448 *perr = NT_STATUS_FILE_INVALID;
449 goto error_exit;
450 }
451
452 /* The header may be a PE (Portable Executable) or an NE (New Executable) */
453 if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
454 if (SVAL(buf,PE_HEADER_MACHINE_OFFSET) == PE_HEADER_MACHINE_I386) {
455
456 switch (SVAL(buf,PE_HEADER_MAJOR_OS_VER_OFFSET)) {
457 case 4: cversion = 2; break; /* Win NT 4 */
458 case 5: cversion = 3; break; /* Win 2000 */
459 default:
460 DEBUG(6,("get_correct_cversion: PE formated file [%s] bad version = %d\n",
461 driverpath, SVAL(buf,PE_HEADER_MAJOR_OS_VER_OFFSET)));
462 *perr = NT_STATUS_FILE_INVALID;
463 goto error_exit;
464 }
465 } else {
466 DEBUG(6,("get_correct_cversion: PE formatted file [%s] wrong machine = 0x%x\n",
467 driverpath, SVAL(buf,PE_HEADER_MACHINE_OFFSET)));
468 *perr = NT_STATUS_FILE_INVALID;
469 goto error_exit;
470 }
471
472 } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
473 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) == NE_HEADER_TARGOS_WIN ) {
474
475 switch (CVAL(buf,NE_HEADER_MAJOR_VER_OFFSET)) {
476 case 3: cversion = 0; break; /* Win 3.x / Win 9x / Win ME */
477 /* case ?: cversion = 1; break;*/ /* Win NT 3.51 ... needs research JRR */
478 default:
479 DEBUG(6,("get_correct_cversion: NE formated file [%s] bad version = %d\n",
480 driverpath, CVAL(buf,NE_HEADER_MAJOR_VER_OFFSET)));
481 *perr = NT_STATUS_FILE_INVALID;
482 goto error_exit;
483 }
484 } else {
485 DEBUG(6,("get_correct_cversion: NE formatted file [%s] wrong target OS = 0x%x\n",
486 driverpath, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
487 *perr = NT_STATUS_FILE_INVALID;
488 goto error_exit;
489 }
490
491 } else {
492 DEBUG(6,("get_correct_cversion: Unknown file format [%s], signature = 0x%x\n",
493 driverpath, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
494 *perr = NT_STATUS_FILE_INVALID;
495 goto error_exit;
496 }
497
498 DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
499 driverpath, cversion));
500
501 fsp->conn->vfs_ops.close(fsp, fsp->fd);
502 file_free(fsp);
503 close_cnum(conn, user->vuid);
504 pop_sec_ctx();
505 return cversion;
506
507
508 error_exit:
509 if(fsp) {
510 if(fsp->fd != -1)
511 fsp->conn->vfs_ops.close(fsp, fsp->fd);
512 file_free(fsp);
513 }
514
515 close_cnum(conn, user->vuid);
516 pop_sec_ctx();
517 return -1;
518 }
519
520 /****************************************************************************
521 ****************************************************************************/
522 static uint32 clean_up_driver_struct_level_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver,
523 struct current_user *user)
524 {
525 fstring architecture;
526 fstring new_name;
527 char *p;
528 int i;
529 uint32 err;
530
531 /* clean up the driver name.
532 * we can get .\driver.dll
533 * or worse c:\windows\system\driver.dll !
534 */
535 /* using an intermediate string to not have overlaping memcpy()'s */
536 if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
537 fstrcpy(new_name, p+1);
538 fstrcpy(driver->driverpath, new_name);
539 }
540
541 if ((p = strrchr(driver->datafile,'\\')) != NULL) {
542 fstrcpy(new_name, p+1);
543 fstrcpy(driver->datafile, new_name);
544 }
545
546 if ((p = strrchr(driver->configfile,'\\')) != NULL) {
547 fstrcpy(new_name, p+1);
548 fstrcpy(driver->configfile, new_name);
549 }
550
551 if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
552 fstrcpy(new_name, p+1);
553 fstrcpy(driver->helpfile, new_name);
554 }
555
556 if (driver->dependentfiles) {
557 for (i=0; *driver->dependentfiles[i]; i++) {
558 if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
559 fstrcpy(new_name, p+1);
560 fstrcpy(driver->dependentfiles[i], new_name);
561 }
562 }
563 }
564
565 get_short_archi(architecture, driver->environment);
566
567 /* jfm:7/16/2000 the client always sends the cversion=0.
568 * The server should check which version the driver is by reading
569 * the PE header of driver->driverpath.
570 *
571 * For Windows 95/98 the version is 0 (so the value sent is correct)
572 * For Windows NT (the architecture doesn't matter)
573 * NT 3.1: cversion=0
574 * NT 3.5/3.51: cversion=1
575 * NT 4: cversion=2
576 * NT2K: cversion=3
577 */
578 if ((driver->cversion = get_correct_cversion( architecture,
579 driver->driverpath, user, &err)) == -1)
580 return err;
581
582 return NT_STATUS_NO_PROBLEMO;
583 }
584
585 /****************************************************************************
586 ****************************************************************************/
587 static uint32 clean_up_driver_struct_level_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver,
588 struct current_user *user)
589 {
590 fstring architecture;
591 fstring new_name;
592 char *p;
593 int i;
594 uint32 err;
595
596 /* clean up the driver name.
597 * we can get .\driver.dll
598 * or worse c:\windows\system\driver.dll !
599 */
600 /* using an intermediate string to not have overlaping memcpy()'s */
601 if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
602 fstrcpy(new_name, p+1);
603 fstrcpy(driver->driverpath, new_name);
604 }
605
606 if ((p = strrchr(driver->datafile,'\\')) != NULL) {
607 fstrcpy(new_name, p+1);
608 fstrcpy(driver->datafile, new_name);
609 }
610
611 if ((p = strrchr(driver->configfile,'\\')) != NULL) {
612 fstrcpy(new_name, p+1);
613 fstrcpy(driver->configfile, new_name);
614 }
615
616 if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
617 fstrcpy(new_name, p+1);
618 fstrcpy(driver->helpfile, new_name);
619 }
620
621 if (driver->dependentfiles) {
622 for (i=0; *driver->dependentfiles[i]; i++) {
623 if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
624 fstrcpy(new_name, p+1);
625 fstrcpy(driver->dependentfiles[i], new_name);
626 }
627 }
628 }
629
630 get_short_archi(architecture, driver->environment);
631
632 /* jfm:7/16/2000 the client always sends the cversion=0.
633 * The server should check which version the driver is by reading
634 * the PE header of driver->driverpath.
635 *
636 * For Windows 95/98 the version is 0 (so the value sent is correct)
637 * For Windows NT (the architecture doesn't matter)
638 * NT 3.1: cversion=0
639 * NT 3.5/3.51: cversion=1
640 * NT 4: cversion=2
641 * NT2K: cversion=3
642 */
643 if ((driver->version = get_correct_cversion(architecture,
644 driver->driverpath, user, &err)) == -1)
645 return err;
646
647 return NT_STATUS_NO_PROBLEMO;
648 }
649
650 /****************************************************************************
651 ****************************************************************************/
652 uint32 clean_up_driver_struct(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
653 uint32 level, struct current_user *user)
654 {
655 switch (level) {
656 case 3:
657 {
658 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
659 driver=driver_abstract.info_3;
660 return clean_up_driver_struct_level_3(driver, user);
661 }
662 case 6:
663 {
664 NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver;
665 driver=driver_abstract.info_6;
666 return clean_up_driver_struct_level_6(driver, user);
667 }
668 default:
669 return ERROR_INVALID_PARAMETER;
670 }
671 }
672
673 /****************************************************************************
674 This function sucks and should be replaced. JRA.
675 ****************************************************************************/
676
677 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *dst, NT_PRINTER_DRIVER_INFO_LEVEL_6 *src)
678 {
679 dst->cversion = src->version;
680
681 fstrcpy( dst->name, src->name);
682 fstrcpy( dst->environment, src->environment);
683 fstrcpy( dst->driverpath, src->driverpath);
684 fstrcpy( dst->datafile, src->datafile);
685 fstrcpy( dst->configfile, src->configfile);
686 fstrcpy( dst->helpfile, src->helpfile);
687 fstrcpy( dst->monitorname, src->monitorname);
688 fstrcpy( dst->defaultdatatype, src->defaultdatatype);
689 dst->dependentfiles = src->dependentfiles;
690 }
691
692 #if 0 /* Debugging function */
693
694 static char* ffmt(unsigned char *c){
695 int i;
696 static char ffmt_str[17];
697
698 for (i=0; i<16; i++) {
699 if ((c[i] < ' ') || (c[i] > '~'))
700 ffmt_str[i]='.';
701 else
702 ffmt_str[i]=c[i];
703 }
704 ffmt_str[16]='\0';
705 return ffmt_str;
706 }
707
708 #endif
709
710 /****************************************************************************
711 Version information in Microsoft files is held in a VS_VERSION_INFO structure.
712 There are two case to be covered here: PE (Portable Executable) and NE (New
713 Executable) files. Both files support the same INFO structure, but PE files
714 store the signature in unicode, and NE files store it as !unicode.
715 ****************************************************************************/
716 static BOOL get_file_version(files_struct *fsp, char *fname,uint32 *major,
717 uint32 *minor)
718 {
719 int i;
720 char *buf;
721 ssize_t byte_count;
722
723 if ((buf=malloc(PE_HEADER_SIZE)) == NULL) {
724 DEBUG(0,("get_file_version: PE file [%s] PE Header malloc failed bytes = %d\n",
725 fname, PE_HEADER_SIZE));
726 goto error_exit;
727 }
728
729 /* Note: DOS_HEADER_SIZE < malloc'ed PE_HEADER_SIZE */
730 if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
731 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %d\n",
732 fname, byte_count));
733 goto no_version_info;
734 }
735
736 /* Is this really a DOS header? */
737 if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
738 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
739 fname, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
740 goto no_version_info;
741 }
742
743 /* Skip OEM header (if any) and the DOS stub to start of Windows header */
744 if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
745 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
746 fname, errno));
747 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
748 goto no_version_info;
749 }
750
751 if ((byte_count = vfs_read_data(fsp, buf, PE_HEADER_SIZE)) < PE_HEADER_SIZE) {
752 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %d\n",
753 fname, byte_count));
754 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
755 goto no_version_info;
756 }
757
758 /* The header may be a PE (Portable Executable) or an NE (New Executable) */
759 if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
760 int num_sections;
761 int section_table_bytes;
762
763 if (SVAL(buf,PE_HEADER_MACHINE_OFFSET) != PE_HEADER_MACHINE_I386) {
764 DEBUG(3,("get_file_version: PE file [%s] wrong machine = 0x%x\n",
765 fname, SVAL(buf,PE_HEADER_MACHINE_OFFSET)));
766 /* At this point, we assume the file is in error. It still could be somthing
767 * else besides a PE file, but it unlikely at this point.
768 */
769 goto error_exit;
770 }
771
772 /* get the section table */
773 num_sections = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS);
774 section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE;
775 free(buf);
776 if ((buf=malloc(section_table_bytes)) == NULL) {
777 DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
778 fname, section_table_bytes));
779 goto error_exit;
780 }
781
782 if ((byte_count = vfs_read_data(fsp, buf, section_table_bytes)) < section_table_bytes) {
783 DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %d\n",
784 fname, byte_count));
785 goto error_exit;
786 }
787
788 /* Iterate the section table looking for the resource section ".rsrc" */
789 for (i = 0; i < num_sections; i++) {
790 int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE;
791
792 if (strcmp(".rsrc", &buf[sec_offset+PE_HEADER_SECT_NAME_OFFSET]) == 0) {
793 int section_pos = IVAL(buf,sec_offset+PE_HEADER_SECT_PTR_DATA_OFFSET);
794 int section_bytes = IVAL(buf,sec_offset+PE_HEADER_SECT_SIZE_DATA_OFFSET);
795
796 free(buf);
797 if ((buf=malloc(section_bytes)) == NULL) {
798 DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
799 fname, section_bytes));
800 goto error_exit;
801 }
802
803 /* Seek to the start of the .rsrc section info */
804 if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
805 DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
806 fname, errno));
807 goto error_exit;
808 }
809
810 if ((byte_count = vfs_read_data(fsp, buf, section_bytes)) < section_bytes) {
811 DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %d\n",
812 fname, byte_count));
813 goto error_exit;
814 }
815
816 for (i=0; i<section_bytes-VS_VERSION_INFO_UNICODE_SIZE; i++) {
817 /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
818 if (buf[i] == 'V' && buf[i+1] == '\0' && buf[i+2] == 'S') {
819 /* Align to next long address */
820 int pos = (i + sizeof(VS_SIGNATURE)*2 + 3) & 0xfffffffc;
821
822 if (IVAL(buf,pos) == VS_MAGIC_VALUE) {
823 *major = IVAL(buf,pos+VS_MAJOR_OFFSET);
824 *minor = IVAL(buf,pos+VS_MINOR_OFFSET);
825
826 DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
827 fname, *major, *minor,
828 (*major>>16)&0xffff, *major&0xffff,
829 (*minor>>16)&0xffff, *minor&0xffff));
830 free(buf);
831 return True;
832 }
833 }
834 }
835 }
836 }
837
838 /* Version info not found, fall back to origin date/time */
839 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname));
840 free(buf);
841 return False;
842
843 } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
844 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) {
845 DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
846 fname, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
847 /* At this point, we assume the file is in error. It still could be somthing
848 * else besides a NE file, but it unlikely at this point. */
849 goto error_exit;
850 }
851
852 /* Allocate a bit more space to speed up things */
853 free(buf);
854 if ((buf=malloc(VS_NE_BUF_SIZE)) == NULL) {
855 DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes = %d\n",
856 fname, PE_HEADER_SIZE));
857 goto error_exit;
858 }
859
860 /* This is a HACK! I got tired of trying to sort through the messy
861 * 'NE' file format. If anyone wants to clean this up please have at
862 * it, but this works. 'NE' files will eventually fade away. JRR */
863 while((byte_count = vfs_read_data(fsp, buf, VS_NE_BUF_SIZE)) > 0) {
864 /* Cover case that should not occur in a well formed 'NE' .dll file */
865 if (byte_count-VS_VERSION_INFO_SIZE <= 0) break;
866
867 for(i=0; i<byte_count; i++) {
868 /* Fast skip past data that can't possibly match */
869 if (buf[i] != 'V') continue;
870
871 /* Potential match data crosses buf boundry, move it to beginning
872 * of buf, and fill the buf with as much as it will hold. */
873 if (i>byte_count-VS_VERSION_INFO_SIZE) {
874 int bc;
875
876 memcpy(buf, &buf[i], byte_count-i);
877 if ((bc = vfs_read_data(fsp, &buf[byte_count-i], VS_NE_BUF_SIZE-
878 (byte_count-i))) < 0) {
879
880 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
881 fname, errno));
882 goto error_exit;
883 }
884
885 byte_count = bc + (byte_count - i);
886 if (byte_count<VS_VERSION_INFO_SIZE) break;
887
888 i = 0;
889 }
890
891 /* Check that the full signature string and the magic number that
892 * follows exist (not a perfect solution, but the chances that this
893 * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
894 * twice, as it is simpler to read the code. */
895 if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
896 /* Compute skip alignment to next long address */
897 int skip = -(fsp->conn->vfs_ops.lseek(fsp, fsp->fd, 0, SEEK_CUR) - (byte_count - i) +
898 sizeof(VS_SIGNATURE)) & 3;
899 if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
900
901 *major = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MAJOR_OFFSET);
902 *minor = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MINOR_OFFSET);
903 DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
904 fname, *major, *minor,
905 (*major>>16)&0xffff, *major&0xffff,
906 (*minor>>16)&0xffff, *minor&0xffff));
907 free(buf);
908 return True;
909 }
910 }
911 }
912
913 /* Version info not found, fall back to origin date/time */
914 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname));
915 free(buf);
916 return False;
917
918 } else
919 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
920 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
921 fname, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
922
923 no_version_info:
924 free(buf);
925 return False;
926
927 error_exit:
928 free(buf);
929 return -1;
930 }
931
932 /****************************************************************************
933 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
934 share one or more files. During the MS installation process files are checked
935 to insure that only a newer version of a shared file is installed over an
936 older version. There are several possibilities for this comparison. If there
937 is no previous version, the new one is newer (obviously). If either file is
938 missing the version info structure, compare the creation date (on Unix use
939 the modification date). Otherwise chose the numerically larger version number.
940 ****************************************************************************/
941 static int file_version_is_newer(connection_struct *conn, fstring new_file,
942 fstring old_file)
943 {
944 BOOL use_version = True;
945 pstring filepath;
946
947 uint32 new_major;
948 uint32 new_minor;
949 time_t new_create_time;
950
951 uint32 old_major;
952 uint32 old_minor;
953 time_t old_create_time;
954
955 int access_mode;
956 int action;
957 files_struct *fsp = NULL;
958 SMB_STRUCT_STAT st;
959 SMB_STRUCT_STAT stat_buf;
960 BOOL bad_path;
961
962 ZERO_STRUCT(st);
963 ZERO_STRUCT(stat_buf);
964 new_create_time = (time_t)0;
965 old_create_time = (time_t)0;
966
967 /* Get file version info (if available) for previous file (if it exists) */
968 pstrcpy(filepath, old_file);
969
970 unix_convert(filepath,conn,NULL,&bad_path,&stat_buf);
971
972 fsp = open_file_shared(conn, filepath, &stat_buf,
973 SET_OPEN_MODE(DOS_OPEN_RDONLY),
974 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
975 0, 0, &access_mode, &action);
976 if (!fsp) {
977 /* Old file not found, so by definition new file is in fact newer */
978 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
979 filepath, errno));
980 return True;
981
982 } else {
983 int ret = get_file_version(fsp, old_file, &old_major, &old_minor);
984 if (ret == -1) goto error_exit;
985
986 if (!ret) {
987 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
988 old_file));
989 use_version = False;
990 if (fsp->conn->vfs_ops.fstat(fsp, fsp->fd, &st) == -1) goto error_exit;
991 old_create_time = st.st_mtime;
992 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", old_create_time));
993 }
994 }
995 fsp->conn->vfs_ops.close(fsp, fsp->fd);
996 file_free(fsp);
997
998
999 /* Get file version info (if available) for new file */
1000 pstrcpy(filepath, new_file);
1001 unix_convert(filepath,conn,NULL,&bad_path,&stat_buf);
1002
1003 fsp = open_file_shared(conn, filepath, &stat_buf,
1004 SET_OPEN_MODE(DOS_OPEN_RDONLY),
1005 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
1006 0, 0, &access_mode, &action);
1007 if (!fsp) {
1008 /* New file not found, this shouldn't occur if the caller did its job */
1009 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1010 filepath, errno));
1011 goto error_exit;
1012
1013 } else {
1014 int ret = get_file_version(fsp, new_file, &new_major, &new_minor);
1015 if (ret == -1) goto error_exit;
1016
1017 if (!ret) {
1018 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1019 new_file));
1020 use_version = False;
1021 if (fsp->conn->vfs_ops.fstat(fsp, fsp->fd, &st) == -1) goto error_exit;
1022 new_create_time = st.st_mtime;
1023 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", new_create_time));
1024 }
1025 }
1026 fsp->conn->vfs_ops.close(fsp, fsp->fd);
1027 file_free(fsp);
1028
1029 if (use_version) {
1030 /* Compare versions and choose the larger version number */
1031 if (new_major > old_major ||
1032 (new_major == old_major && new_minor > old_minor)) {
1033
1034 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1035 return True;
1036 }
1037 else {
1038 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1039 return False;
1040 }
1041
1042 } else {
1043 /* Compare modification time/dates and choose the newest time/date */
1044 if (new_create_time > old_create_time) {
1045 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1046 return True;
1047 }
1048 else {
1049 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1050 return False;
1051 }
1052 }
1053
1054 error_exit:
1055 if(fsp) {
1056 file_free(fsp);
1057 if(fsp->fd != -1)
1058 fsp->conn->vfs_ops.close(fsp, fsp->fd);
1059 }
1060 return -1;
1061 }
1062
1063 /****************************************************************************
1064 ****************************************************************************/
1065 BOOL move_driver_to_download_area(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract, uint32 level, struct current_user *user, uint32 *perr)
1066 {
1067 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1068 NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver;
1069 fstring architecture;
1070 pstring new_dir;
1071 pstring old_name;
1072 pstring new_name;
1073 fstring user_name;
1074 fstring null_pw;
1075 connection_struct *conn;
1076 pstring inbuf;
1077 pstring outbuf;
1078 struct passwd *pass;
1079 int ecode;
1080 int ver = 0;
1081 int outsize = 0;
1082 int i;
1083
1084 *perr = 0;
1085 memset(inbuf, '\0', sizeof(inbuf));
1086 memset(outbuf, '\0', sizeof(outbuf));
1087
1088 if (level==3)
1089 driver=driver_abstract.info_3;
1090 else if (level==6) {
1091 convert_level_6_to_level3(&converted_driver, driver_abstract.info_6);
1092 driver = &converted_driver;
1093 } else {
1094 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level ));
1095 return False;
1096 }
1097
1098 get_short_archi(architecture, driver->environment);
1099
1100 become_root();
1101 pass = getpwuid(user->uid);
1102 if(pass == NULL) {
1103 DEBUG(0,("move_driver_to_download_area: Unable to get passwd entry for uid %u\n",
1104 (unsigned int)user->uid ));
1105 unbecome_root();
1106 return False;
1107 }
1108 unbecome_root();
1109
1110 /* connect to the print$ share under the same account as the user connected to the rpc pipe */
1111 fstrcpy(user_name, pass->pw_name );
1112 DEBUG(10,("move_driver_to_download_area: uid %d -> user %s\n", (int)user->uid, user_name));
1113
1114 /* Null password is ok - we are already an authenticated user... */
1115 *null_pw = '\0';
1116 conn = make_connection("print$", user_name, null_pw, 0, "A:", user->vuid, &ecode);
1117
1118 if (conn == NULL) {
1119 DEBUG(0,("move_driver_to_download_area: Unable to connect\n"));
1120 *perr = (uint32)ecode;
1121 return False;
1122 }
1123
1124 /*
1125 * Save who we are - we are temporarily becoming the connection user.
1126 */
1127
1128 push_sec_ctx();
1129
1130 if (!become_user(conn, conn->vuid)) {
1131 DEBUG(0,("move_driver_to_download_area: Can't become user %s\n", user_name ));
1132 pop_sec_ctx();
1133 return False;
1134 }
1135
1136 /*
1137 * make the directories version and version\driver_name
1138 * under the architecture directory.
1139 */
1140 DEBUG(5,("Creating first directory\n"));
1141 slprintf(new_dir, sizeof(new_dir), "%s/%d", architecture, driver->cversion);
1142 mkdir_internal(conn, inbuf, outbuf, new_dir);
1143
1144 /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1145 * listed for this driver which has already been moved, skip it (note:
1146 * drivers may list the same file name several times. Then check if the
1147 * file already exists in archi\cversion\, if so, check that the version
1148 * info (or time stamps if version info is unavailable) is newer (or the
1149 * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1150 * Otherwise, delete the file.
1151 *
1152 * If a file is not moved to archi\cversion\ because of an error, all the
1153 * rest of the 'unmoved' driver files are removed from archi\. If one or
1154 * more of the driver's files was already moved to archi\cversion\, it
1155 * potentially leaves the driver in a partially updated state. Version
1156 * trauma will most likely occur if an client attempts to use any printer
1157 * bound to the driver. Perhaps a rewrite to make sure the moves can be
1158 * done is appropriate... later JRR
1159 */
1160
1161 DEBUG(5,("Moving files now !\n"));
1162
1163 if (driver->driverpath && strlen(driver->driverpath)) {
1164 slprintf(new_name, sizeof(new_name), "%s/%s", architecture, driver->driverpath);
1165 slprintf(old_name, sizeof(old_name), "%s/%s", new_dir, driver->driverpath);
1166 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1167 if ((outsize = rename_internals(conn, inbuf, outbuf, new_name, old_name, True)) != 0) {
1168 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1169 new_name, old_name));
1170 *perr = (uint32)SVAL(outbuf,smb_err);
1171 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1172 ver = -1;
1173 }
1174 }
1175 else
1176 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1177 }
1178
1179 if (driver->datafile && strlen(driver->datafile)) {
1180 if (!strequal(driver->datafile, driver->driverpath)) {
1181 slprintf(new_name, sizeof(new_name), "%s/%s", architecture, driver->datafile);
1182 slprintf(old_name, sizeof(old_name), "%s/%s", new_dir, driver->datafile);
1183 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1184 if ((outsize = rename_internals(conn, inbuf, outbuf, new_name, old_name, True)) != 0) {
1185 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1186 new_name, old_name));
1187 *perr = (uint32)SVAL(outbuf,smb_err);
1188 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1189 ver = -1;
1190 }
1191 }
1192 else
1193 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1194 }
1195 }
1196
1197 if (driver->configfile && strlen(driver->configfile)) {
1198 if (!strequal(driver->configfile, driver->driverpath) &&
1199 !strequal(driver->configfile, driver->datafile)) {
1200 slprintf(new_name, sizeof(new_name), "%s/%s", architecture, driver->configfile);
1201 slprintf(old_name, sizeof(old_name), "%s/%s", new_dir, driver->configfile);
1202 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1203 if ((outsize = rename_internals(conn, inbuf, outbuf, new_name, old_name, True)) != 0) {
1204 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1205 new_name, old_name));
1206 *perr = (uint32)SVAL(outbuf,smb_err);
1207 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1208 ver = -1;
1209 }
1210 }
1211 else
1212 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1213 }
1214 }
1215
1216 if (driver->helpfile && strlen(driver->helpfile)) {
1217 if (!strequal(driver->helpfile, driver->driverpath) &&
1218 !strequal(driver->helpfile, driver->datafile) &&
1219 !strequal(driver->helpfile, driver->configfile)) {
1220 slprintf(new_name, sizeof(new_name), "%s/%s", architecture, driver->helpfile);
1221 slprintf(old_name, sizeof(old_name), "%s/%s", new_dir, driver->helpfile);
1222 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1223 if ((outsize = rename_internals(conn, inbuf, outbuf, new_name, old_name, True)) != 0) {
1224 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1225 new_name, old_name));
1226 *perr = (uint32)SVAL(outbuf,smb_err);
1227 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1228 ver = -1;
1229 }
1230 }
1231 else
1232 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1233 }
1234 }
1235
1236 if (driver->dependentfiles) {
1237 for (i=0; *driver->dependentfiles[i]; i++) {
1238 if (!strequal(driver->dependentfiles[i], driver->driverpath) &&
1239 !strequal(driver->dependentfiles[i], driver->datafile) &&
1240 !strequal(driver->dependentfiles[i], driver->configfile) &&
1241 !strequal(driver->dependentfiles[i], driver->helpfile)) {
1242 int j;
1243 for (j=0; j < i; j++) {
1244 if (strequal(driver->dependentfiles[i], driver->dependentfiles[j])) {
1245 goto NextDriver;
1246 }
1247 }
1248
1249 slprintf(new_name, sizeof(new_name), "%s/%s", architecture, driver->dependentfiles[i]);
1250 slprintf(old_name, sizeof(old_name), "%s/%s", new_dir, driver->dependentfiles[i]);
1251 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1252 if ((outsize = rename_internals(conn, inbuf, outbuf, new_name, old_name, True)) != 0) {
1253 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1254 new_name, old_name));
1255 *perr = (uint32)SVAL(outbuf,smb_err);
1256 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1257 ver = -1;
1258 }
1259 }
1260 else
1261 unlink_internals(conn, inbuf, outbuf, 0, new_name);
1262 }
1263 NextDriver: ;
1264 }
1265 }
1266
1267 close_cnum(conn, user->vuid);
1268 pop_sec_ctx();
1269
1270 return ver == -1 ? False : True;
1271 }
1272
1273 /****************************************************************************
1274 ****************************************************************************/
1275 static uint32 add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
1276 {
1277 int len, buflen;
1278 fstring architecture;
1279 pstring directory;
1280 pstring temp_name;
1281 pstring key;
1282 char *buf;
1283 int i, ret;
1284 TDB_DATA kbuf, dbuf;
1285
1286 get_short_archi(architecture, driver->environment);
1287
1288 /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
1289 * \\server is added in the rpc server layer.
1290 * It does make sense to NOT store the server's name in the printer TDB.
1291 */
1292
1293 slprintf(directory, sizeof(directory), "\\print$\\%s\\%d\\", architecture, driver->cversion);
1294
1295
1296 fstrcpy(temp_name, driver->driverpath);
1297 slprintf(driver->driverpath, sizeof(driver->driverpath), "%s%s", directory, temp_name);
1298
1299 fstrcpy(temp_name, driver->datafile);
1300 slprintf(driver->datafile, sizeof(driver->datafile), "%s%s", directory, temp_name);
1301
1302 fstrcpy(temp_name, driver->configfile);
1303 slprintf(driver->configfile, sizeof(driver->configfile), "%s%s", directory, temp_name);
1304
1305 fstrcpy(temp_name, driver->helpfile);
1306 slprintf(driver->helpfile, sizeof(driver->helpfile), "%s%s", directory, temp_name);
1307
1308 if (driver->dependentfiles) {
1309 for (i=0; *driver->dependentfiles[i]; i++) {
1310 fstrcpy(temp_name, driver->dependentfiles[i]);
1311 slprintf(driver->dependentfiles[i], sizeof(driver->dependentfiles[i]), "%s%s", directory, temp_name);
1312 }
1313 }
1314
1315 slprintf(key, sizeof(key), "%s%s/%d/%s", DRIVERS_PREFIX, architecture, driver->cversion, driver->name);
1316
1317 DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key ));
1318
1319 buf = NULL;
1320 len = buflen = 0;
1321
1322 again:
1323 len = 0;
1324 len += tdb_pack(buf+len, buflen-len, "dffffffff",
1325 driver->cversion,
1326 driver->name,
1327 driver->environment,
1328 driver->driverpath,
1329 driver->datafile,
1330 driver->configfile,
1331 driver->helpfile,
1332 driver->monitorname,
1333 driver->defaultdatatype);
1334
1335 if (driver->dependentfiles) {
1336 for (i=0; *driver->dependentfiles[i]; i++) {
1337 len += tdb_pack(buf+len, buflen-len, "f",
1338 driver->dependentfiles[i]);
1339 }
1340 }
1341
1342 if (len != buflen) {
1343 buf = (char *)Realloc(buf, len);
1344 buflen = len;
1345 goto again;
1346 }
1347
1348
1349 kbuf.dptr = key;
1350 kbuf.dsize = strlen(key)+1;
1351 dbuf.dptr = buf;
1352 dbuf.dsize = len;
1353
1354 ret = tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
1355
1356 if (ret)
1357 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key ));
1358
1359 safe_free(buf);
1360 return ret;
1361 }
1362
1363 /****************************************************************************
1364 ****************************************************************************/
1365 static uint32 add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
1366 {
1367 NT_PRINTER_DRIVER_INFO_LEVEL_3 info3;
1368
1369 ZERO_STRUCT(info3);
1370 info3.cversion = driver->version;
1371 fstrcpy(info3.name,driver->name);
1372 fstrcpy(info3.environment,driver->environment);
1373 fstrcpy(info3.driverpath,driver->driverpath);
1374 fstrcpy(info3.datafile,driver->datafile);
1375 fstrcpy(info3.configfile,driver->configfile);
1376 fstrcpy(info3.helpfile,driver->helpfile);
1377 fstrcpy(info3.monitorname,driver->monitorname);
1378 fstrcpy(info3.defaultdatatype,driver->defaultdatatype);
1379 info3.dependentfiles = driver->dependentfiles;
1380
1381 return add_a_printer_driver_3(&info3);
1382 }
1383
1384
1385 /****************************************************************************
1386 ****************************************************************************/
1387 static uint32 get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring in_prt, fstring in_arch)
1388 {
1389 NT_PRINTER_DRIVER_INFO_LEVEL_3 info;
1390
1391 ZERO_STRUCT(info);
1392
1393 fstrcpy(info.name, in_prt);
1394 fstrcpy(info.defaultdatatype, "RAW");
1395
1396 fstrcpy(info.driverpath, "");
1397 fstrcpy(info.datafile, "");
1398 fstrcpy(info.configfile, "");
1399 fstrcpy(info.helpfile, "");
1400
1401 if ((info.dependentfiles=(fstring *)malloc(2*sizeof(fstring))) == NULL)
1402 return ERROR_NOT_ENOUGH_MEMORY;
1403
1404 memset(info.dependentfiles, '\0', 2*sizeof(fstring));
1405 fstrcpy(info.dependentfiles[0], "");
1406
1407 *info_ptr = memdup(&info, sizeof(info));
1408
1409 return 0;
1410 }
1411
1412 /****************************************************************************
1413 ****************************************************************************/
1414 static uint32 get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring in_prt, fstring in_arch, uint32 version)
1415 {
1416 NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
1417 TDB_DATA kbuf, dbuf;
1418 fstring architecture;
1419 int len = 0;
1420 int i;
1421 pstring key;
1422
1423 ZERO_STRUCT(driver);
1424
1425 get_short_archi(architecture, in_arch);
1426
1427 DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX, architecture, version, in_prt));
1428
1429 slprintf(key, sizeof(key), "%s%s/%d/%s", DRIVERS_PREFIX, architecture, version, in_prt);
1430
1431 kbuf.dptr = key;
1432 kbuf.dsize = strlen(key)+1;
1433
1434 dbuf = tdb_fetch(tdb, kbuf);
1435 #if 0
1436 if (!dbuf.dptr) return get_a_printer_driver_3_default(info_ptr, in_prt, in_arch);
1437 #else
1438 if (!dbuf.dptr) return 5;
1439 #endif
1440 len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
1441 &driver.cversion,
1442 driver.name,
1443 driver.environment,
1444 driver.driverpath,
1445 driver.datafile,
1446 driver.configfile,
1447 driver.helpfile,
1448 driver.monitorname,
1449 driver.defaultdatatype);
1450
1451 i=0;
1452 while (len < dbuf.dsize) {
1453 driver.dependentfiles = (fstring *)Realloc(driver.dependentfiles,
1454 sizeof(fstring)*(i+2));
1455 if (driver.dependentfiles == NULL)
1456 break;
1457
1458 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
1459 &driver.dependentfiles[i]);
1460 i++;
1461 }
1462 if (driver.dependentfiles != NULL)
1463 fstrcpy(driver.dependentfiles[i], "");
1464
1465 safe_free(dbuf.dptr);
1466
1467 if (len != dbuf.dsize) {
1468 if (driver.dependentfiles != NULL)
1469 safe_free(driver.dependentfiles);
1470
1471 return get_a_printer_driver_3_default(info_ptr, in_prt, in_arch);
1472 }
1473
1474 *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&driver, sizeof(driver));
1475
1476 return 0;
1477 }
1478
1479 /****************************************************************************
1480 ****************************************************************************/
1481 uint32 get_a_printer_driver_9x_compatible(pstring line, fstring model)
1482 {
1483 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
1484 TDB_DATA kbuf;
1485 pstring key;
1486 int i;
1487 line[0] = '\0';
1488
1489 slprintf(key, sizeof(key), "%s%s/%d/%s", DRIVERS_PREFIX, "WIN40", 0, model);
1490 DEBUG(10,("driver key: [%s]\n", key));
1491
1492 kbuf.dptr = key;
1493 kbuf.dsize = strlen(key)+1;
1494 if (!tdb_exists(tdb, kbuf)) return False;
1495
1496 ZERO_STRUCT(info3);
1497 get_a_printer_driver_3(&info3, model, "Windows 4.0", 0);
1498
1499 DEBUGADD(10,("info3->name [%s]\n", info3->name));
1500 DEBUGADD(10,("info3->datafile [%s]\n", info3->datafile));
1501 DEBUGADD(10,("info3->helpfile [%s]\n", info3->helpfile));
1502 DEBUGADD(10,("info3->monitorname [%s]\n", info3->monitorname));
1503 DEBUGADD(10,("info3->defaultdatatype [%s]\n", info3->defaultdatatype));
1504 for (i=0; info3->dependentfiles && *info3->dependentfiles[i]; i++) {
1505 DEBUGADD(10,("info3->dependentfiles [%s]\n", info3->dependentfiles[i]));
1506 }
1507 DEBUGADD(10,("info3->environment [%s]\n", info3->environment));
1508 DEBUGADD(10,("info3->driverpath [%s]\n", info3->driverpath));
1509 DEBUGADD(10,("info3->configfile [%s]\n", info3->configfile));
1510
1511 /*pstrcat(line, info3->name); pstrcat(line, ":");*/
1512 trim_string(info3->configfile, "\\print$\\WIN40\\0\\", 0);
1513 pstrcat(line, info3->configfile);
1514 pstrcat(line, ":");
1515 trim_string(info3->datafile, "\\print$\\WIN40\\0\\", 0);
1516 pstrcat(line, info3->datafile);
1517 pstrcat(line, ":");
1518 trim_string(info3->helpfile, "\\print$\\WIN40\\0\\", 0);
1519 pstrcat(line, info3->helpfile);
1520 pstrcat(line, ":");
1521 trim_string(info3->monitorname, "\\print$\\WIN40\\0\\", 0);
1522 pstrcat(line, info3->monitorname);
1523 pstrcat(line, ":");
1524 pstrcat(line, "RAW"); /*info3->defaultdatatype);*/
1525 pstrcat(line, ":");
1526
1527 for (i=0; info3->dependentfiles &&
1528 *info3->dependentfiles[i]; i++) {
1529 if (i) pstrcat(line, ","); /* don't end in a "," */
1530 trim_string(info3->dependentfiles[i], "\\print$\\WIN40\\0\\", 0);
1531 pstrcat(line, info3->dependentfiles[i]);
1532 }
1533
1534 free(info3);
1535
1536 return True;
1537 }
1538
1539 /****************************************************************************
1540 debugging function, dump at level 6 the struct in the logs
1541 ****************************************************************************/
1542 static uint32 dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
1543 {
1544 uint32 result;
1545 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
1546 int i;
1547
1548 DEBUG(106,("Dumping printer driver at level [%d]\n", level));
1549
1550 switch (level)
1551 {
1552 case 3:
1553 {
1554 if (driver.info_3 == NULL)
1555 result=5;
1556 else {
1557 info3=driver.info_3;
1558
1559 DEBUGADD(106,("version:[%d]\n", info3->cversion));
1560 DEBUGADD(106,("name:[%s]\n", info3->name));
1561 DEBUGADD(106,("environment:[%s]\n", info3->environment));
1562 DEBUGADD(106,("driverpath:[%s]\n", info3->driverpath));
1563 DEBUGADD(106,("datafile:[%s]\n", info3->datafile));
1564 DEBUGADD(106,("configfile:[%s]\n", info3->configfile));
1565 DEBUGADD(106,("helpfile:[%s]\n", info3->helpfile));
1566 DEBUGADD(106,("monitorname:[%s]\n", info3->monitorname));
1567 DEBUGADD(106,("defaultdatatype:[%s]\n", info3->defaultdatatype));
1568
1569 for (i=0; info3->dependentfiles &&
1570 *info3->dependentfiles[i]; i++) {
1571 DEBUGADD(106,("dependentfile:[%s]\n",
1572 info3->dependentfiles[i]));
1573 }
1574 result=0;
1575 }
1576 break;
1577 }
1578 default:
1579 DEBUGADD(1,("Level not implemented\n"));
1580 result=1;
1581 break;
1582 }
1583
1584 return result;
1585 }
1586
1587 /****************************************************************************
1588 ****************************************************************************/
1589 static int pack_devicemode(NT_DEVICEMODE *nt_devmode, char *buf, int buflen)
1590 {
1591 int len = 0;
1592
1593 len += tdb_pack(buf+len, buflen-len, "p", nt_devmode);
1594
1595 if (!nt_devmode) return len;
1596
1597 len += tdb_pack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
1598 nt_devmode->devicename,
1599 nt_devmode->formname,
1600
1601 nt_devmode->specversion,
1602 nt_devmode->driverversion,
1603 nt_devmode->size,
1604 nt_devmode->driverextra,
1605 nt_devmode->orientation,
1606 nt_devmode->papersize,
1607 nt_devmode->paperlength,
1608 nt_devmode->paperwidth,
1609 nt_devmode->scale,
1610 nt_devmode->copies,
1611 nt_devmode->defaultsource,
1612 nt_devmode->printquality,
1613 nt_devmode->color,
1614 nt_devmode->duplex,
1615 nt_devmode->yresolution,
1616 nt_devmode->ttoption,
1617 nt_devmode->collate,
1618 nt_devmode->logpixels,
1619
1620 nt_devmode->fields,
1621 nt_devmode->bitsperpel,
1622 nt_devmode->pelswidth,
1623 nt_devmode->pelsheight,
1624 nt_devmode->displayflags,
1625 nt_devmode->displayfrequency,
1626 nt_devmode->icmmethod,
1627 nt_devmode->icmintent,
1628 nt_devmode->mediatype,
1629 nt_devmode->dithertype,
1630 nt_devmode->reserved1,
1631 nt_devmode->reserved2,
1632 nt_devmode->panningwidth,
1633 nt_devmode->panningheight,
1634 nt_devmode->private);
1635
1636
1637 if (nt_devmode->private) {
1638 len += tdb_pack(buf+len, buflen-len, "B",
1639 nt_devmode->driverextra,
1640 nt_devmode->private);
1641 }
1642
1643 DEBUG(8,("Packed devicemode [%s]\n", nt_devmode->formname));
1644
1645 return len;
1646 }
1647
1648 /****************************************************************************
1649 ****************************************************************************/
1650 static int pack_specifics(NT_PRINTER_PARAM *param, char *buf, int buflen)
1651 {
1652 int len = 0;
1653
1654 while (param != NULL) {
1655 len += tdb_pack(buf+len, buflen-len, "pfdB",
1656 param,
1657 param->value,
1658 param->type,
1659 param->data_len,
1660 param->data);
1661 param=param->next;
1662 }
1663
1664 len += tdb_pack(buf+len, buflen-len, "p", param);
1665
1666 return len;
1667 }
1668
1669
1670 /****************************************************************************
1671 delete a printer - this just deletes the printer info file, any open
1672 handles are not affected
1673 ****************************************************************************/
1674 uint32 del_a_printer(char *sharename)
1675 {
1676 pstring key;
1677 TDB_DATA kbuf;
1678
1679 slprintf(key, sizeof(key), "%s%s",
1680 PRINTERS_PREFIX, sharename);
1681
1682 kbuf.dptr=key;
1683 kbuf.dsize=strlen(key)+1;
1684
1685 tdb_delete(tdb, kbuf);
1686 return 0;
1687 }
1688
1689 /****************************************************************************
1690 ****************************************************************************/
1691 static uint32 update_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info)
1692 {
1693 pstring key;
1694 char *buf;
1695 int buflen, len, ret;
1696 TDB_DATA kbuf, dbuf;
1697
1698 /*
1699 * in addprinter: no servername and the printer is the name
1700 * in setprinter: servername is \\server
1701 * and printer is \\server\\printer
1702 *
1703 * Samba manages only local printers.
1704 * we currently don't support things like path=\\other_server\printer
1705 */
1706
1707 if (info->servername[0]!='\0') {
1708 trim_string(info->printername, info->servername, NULL);
1709 trim_string(info->printername, "\\", NULL);
1710 info->servername[0]='\0';
1711 }
1712
1713 /*
1714 * JFM: one day I'll forget.
1715 * below that's info->portname because that's the SAMBA sharename
1716 * and I made NT 'thinks' it's the portname
1717 * the info->sharename is the thing you can name when you add a printer
1718 * that's the short-name when you create shared printer for 95/98
1719 * So I've made a limitation in SAMBA: you can only have 1 printer model
1720 * behind a SAMBA share.
1721 */
1722
1723 buf = NULL;
1724 buflen = 0;
1725
1726 again:
1727 len = 0;
1728 len += tdb_pack(buf+len, buflen-len, "dddddddddddfffffPfffff",
1729 info->attributes,
1730 info->priority,
1731 info->default_priority,
1732 info->starttime,
1733 info->untiltime,
1734 info->status,
1735 info->cjobs,
1736 info->averageppm,
1737 info->changeid,
1738 info->c_setprinter,
1739 info->setuptime,
1740 info->servername,
1741 info->printername,
1742 info->sharename,
1743 info->portname,
1744 info->drivername,
1745 info->comment,
1746 info->location,
1747 info->sepfile,
1748 info->printprocessor,
1749 info->datatype,
1750 info->parameters);
1751
1752 len += pack_devicemode(info->devmode, buf+len, buflen-len);
1753 len += pack_specifics(info->specific, buf+len, buflen-len);
1754
1755 if (buflen != len) {
1756 buf = (char *)Realloc(buf, len);
1757 buflen = len;
1758 goto again;
1759 }
1760
1761
1762 slprintf(key, sizeof(key), "%s%s",
1763 PRINTERS_PREFIX, info->sharename);
1764
1765 kbuf.dptr = key;
1766 kbuf.dsize = strlen(key)+1;
1767 dbuf.dptr = buf;
1768 dbuf.dsize = len;
1769
1770 ret = tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
1771
1772 if (ret == -1)
1773 DEBUG(8, ("error updating printer to tdb on disk\n"));
1774
1775 safe_free(buf);
1776
1777 DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
1778 info->sharename, info->drivername, info->portname, len));
1779
1780 return ret;
1781 }
1782
1783
1784 /****************************************************************************
1785 ****************************************************************************/
1786 void add_a_specific_param(NT_PRINTER_INFO_LEVEL_2 *info_2, NT_PRINTER_PARAM **param)
1787 {
1788 NT_PRINTER_PARAM *current;
1789
1790 DEBUG(108,("add_a_specific_param\n"));
1791
1792 (*param)->next=NULL;
1793
1794 if (info_2->specific == NULL)
1795 {
1796 info_2->specific=*param;
1797 }
1798 else
1799 {
1800 current=info_2->specific;
1801 while (current->next != NULL) {
1802 current=current->next;
1803 }
1804 current->next=*param;
1805 }
1806
1807 *param = NULL;
1808 }
1809
1810 /****************************************************************************
1811 ****************************************************************************/
1812 BOOL unlink_specific_param_if_exist(NT_PRINTER_INFO_LEVEL_2 *info_2, NT_PRINTER_PARAM *param)
1813 {
1814 NT_PRINTER_PARAM *current;
1815 NT_PRINTER_PARAM *previous;
1816
1817 current=info_2->specific;
1818 previous=current;
1819
1820 if (current==NULL) return (False);
1821
1822 if ( !strcmp(current->value, param->value) &&
1823 (strlen(current->value)==strlen(param->value)) ) {
1824 DEBUG(109,("deleting first value\n"));
1825 info_2->specific=current->next;
1826 safe_free(current->data);
1827 safe_free(current);
1828 DEBUG(109,("deleted first value\n"));
1829 return (True);
1830 }
1831
1832 current=previous->next;
1833
1834 while ( current!=NULL ) {
1835 if (!strcmp(current->value, param->value) &&
1836 strlen(current->value)==strlen(param->value) ) {
1837 DEBUG(109,("deleting current value\n"));
1838 previous->next=current->next;
1839 safe_free(current->data);
1840 safe_free(current);
1841 DEBUG(109,("deleted current value\n"));
1842 return(True);
1843 }
1844
1845 previous=previous->next;
1846 current=current->next;
1847 }
1848 return (False);
1849 }
1850
1851 /****************************************************************************
1852 Clean up and deallocate a (maybe partially) allocated NT_PRINTER_PARAM.
1853 ****************************************************************************/
1854 void free_nt_printer_param(NT_PRINTER_PARAM **param_ptr)
1855 {
1856 NT_PRINTER_PARAM *param = *param_ptr;
1857
1858 if(param == NULL)
1859 return;
1860
1861 DEBUG(106,("free_nt_printer_param: deleting param [%s]\n", param->value));
1862
1863 if(param->data)
1864 safe_free(param->data);
1865
1866 safe_free(param);
1867 *param_ptr = NULL;
1868 }
1869
1870 /****************************************************************************
1871 Malloc and return an NT devicemode.
1872 ****************************************************************************/
1873
1874 NT_DEVICEMODE *construct_nt_devicemode(const fstring default_devicename)
1875 {
1876 /*
1877 * should I init this ones ???
1878 nt_devmode->devicename
1879 */
1880
1881 char adevice[32];
1882 NT_DEVICEMODE *nt_devmode = (NT_DEVICEMODE *)malloc(sizeof(NT_DEVICEMODE));
1883
1884 if (nt_devmode == NULL) {
1885 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
1886 return NULL;
1887 }
1888
1889 ZERO_STRUCTP(nt_devmode);
1890
1891 safe_strcpy(adevice, default_devicename, sizeof(adevice));
1892 fstrcpy(nt_devmode->devicename, adevice);
1893
1894 fstrcpy(nt_devmode->formname, "Letter");
1895
1896 nt_devmode->specversion = 0x0401;
1897 nt_devmode->driverversion = 0x0400;
1898 nt_devmode->size = 0x00DC;
1899 nt_devmode->driverextra = 0x0000;
1900 nt_devmode->fields = FORMNAME | TTOPTION | PRINTQUALITY |
1901 DEFAULTSOURCE | COPIES | SCALE |
1902 PAPERSIZE | ORIENTATION;
1903 nt_devmode->orientation = 1;
1904 nt_devmode->papersize = PAPER_LETTER;
1905 nt_devmode->paperlength = 0;
1906 nt_devmode->paperwidth = 0;
1907 nt_devmode->scale = 0x64;
1908 nt_devmode->copies = 01;
1909 nt_devmode->defaultsource = BIN_FORMSOURCE;
1910 nt_devmode->printquality = RES_HIGH; /* 0x0258 */
1911 nt_devmode->color = COLOR_MONOCHROME;
1912 nt_devmode->duplex = DUP_SIMPLEX;
1913 nt_devmode->yresolution = 0;
1914 nt_devmode->ttoption = TT_SUBDEV;
1915 nt_devmode->collate = COLLATE_FALSE;
1916 nt_devmode->icmmethod = 0;
1917 nt_devmode->icmintent = 0;
1918 nt_devmode->mediatype = 0;
1919 nt_devmode->dithertype = 0;
1920
1921 /* non utilisés par un driver d'imprimante */
1922 nt_devmode->logpixels = 0;
1923 nt_devmode->bitsperpel = 0;
1924 nt_devmode->pelswidth = 0;
1925 nt_devmode->pelsheight = 0;
1926 nt_devmode->displayflags = 0;
1927 nt_devmode->displayfrequency = 0;
1928 nt_devmode->reserved1 = 0;
1929 nt_devmode->reserved2 = 0;
1930 nt_devmode->panningwidth = 0;
1931 nt_devmode->panningheight = 0;
1932
1933 nt_devmode->private=NULL;
1934
1935 return nt_devmode;
1936 }
1937
1938 /****************************************************************************
1939 Deepcopy an NT devicemode.
1940 ****************************************************************************/
1941
1942 NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode)
1943 {
1944 NT_DEVICEMODE *new_nt_devicemode = NULL;
1945
1946 if ((new_nt_devicemode = (NT_DEVICEMODE *)memdup(nt_devicemode, sizeof(NT_DEVICEMODE))) == NULL) {
1947 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
1948 return NULL;
1949 }
1950
1951 new_nt_devicemode->private = NULL;
1952 if (nt_devicemode->private != NULL) {
1953 if ((new_nt_devicemode->private = memdup(nt_devicemode->private, nt_devicemode->driverextra)) == NULL) {
1954 safe_free(new_nt_devicemode);
1955 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
1956 return NULL;
1957 }
1958 }
1959
1960 return new_nt_devicemode;
1961 }
1962
1963 /****************************************************************************
1964 Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
1965 ****************************************************************************/
1966
1967 void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr)
1968 {
1969 NT_DEVICEMODE *nt_devmode = *devmode_ptr;
1970
1971 if(nt_devmode == NULL)
1972 return;
1973
1974 DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
1975
1976 if(nt_devmode->private)
1977 safe_free(nt_devmode->private);
1978
1979 safe_free(nt_devmode);
1980 *devmode_ptr = NULL;
1981 }
1982
1983 /****************************************************************************
1984 Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
1985 ****************************************************************************/
1986 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr)
1987 {
1988 NT_PRINTER_INFO_LEVEL_2 *info = *info_ptr;
1989 NT_PRINTER_PARAM *param_ptr;
1990
1991 if(info == NULL)
1992 return;
1993
1994 DEBUG(106,("free_nt_printer_info_level_2: deleting info\n"));
1995
1996 free_nt_devicemode(&info->devmode);
1997 free_sec_desc_buf(&info->secdesc_buf);
1998
1999 for(param_ptr = info->specific; param_ptr; ) {
2000 NT_PRINTER_PARAM *tofree = param_ptr;
2001
2002 param_ptr = param_ptr->next;
2003 free_nt_printer_param(&tofree);
2004 }
2005
2006 safe_free(*info_ptr);
2007 *info_ptr = NULL;
2008 }
2009
2010
2011 /****************************************************************************
2012 ****************************************************************************/
2013 static int unpack_devicemode(NT_DEVICEMODE **nt_devmode, char *buf, int buflen)
2014 {
2015 int len = 0;
2016 int extra_len = 0;
2017 NT_DEVICEMODE devmode;
2018
2019 ZERO_STRUCT(devmode);
2020
2021 len += tdb_unpack(buf+len, buflen-len, "p", nt_devmode);
2022
2023 if (!*nt_devmode) return len;
2024
2025 len += tdb_unpack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2026 devmode.devicename,
2027 devmode.formname,
2028
2029 &devmode.specversion,
2030 &devmode.driverversion,
2031 &devmode.size,
2032 &devmode.driverextra,
2033 &devmode.orientation,
2034 &devmode.papersize,
2035 &devmode.paperlength,
2036 &devmode.paperwidth,
2037 &devmode.scale,
2038 &devmode.copies,
2039 &devmode.defaultsource,
2040 &devmode.printquality,
2041 &devmode.color,
2042 &devmode.duplex,
2043 &devmode.yresolution,
2044 &devmode.ttoption,
2045 &devmode.collate,
2046 &devmode.logpixels,
2047
2048 &devmode.fields,
2049 &devmode.bitsperpel,
2050 &devmode.pelswidth,
2051 &devmode.pelsheight,
2052 &devmode.displayflags,
2053 &devmode.displayfrequency,
2054 &devmode.icmmethod,
2055 &devmode.icmintent,
2056 &devmode.mediatype,
2057 &devmode.dithertype,
2058 &devmode.reserved1,
2059 &devmode.reserved2,
2060 &devmode.panningwidth,
2061 &devmode.panningheight,
2062 &devmode.private);
2063
2064 if (devmode.private) {
2065 /* the len in tdb_unpack is an int value and
2066 * devmoce.driverextra is only a short
2067 */
2068 len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.private);
2069 devmode.driverextra=(uint16)extra_len;
2070
2071 /* check to catch an invalid TDB entry so we don't segfault */
2072 if (devmode.driverextra == 0) {
2073 devmode.private = NULL;
2074 }
2075 }
2076
2077 *nt_devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode));
2078
2079 DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode.devicename, devmode.formname));
2080 if (devmode.private)
2081 DEBUG(8,("with a private section of %d bytes\n", devmode.driverextra));
2082
2083 return len;
2084 }
2085
2086 /****************************************************************************
2087 ****************************************************************************/
2088 static int unpack_specifics(NT_PRINTER_PARAM **list, char *buf, int buflen)
2089 {
2090 int len = 0;
2091 NT_PRINTER_PARAM param, *p;
2092
2093 *list = NULL;
2094
2095 while (1) {
2096 len += tdb_unpack(buf+len, buflen-len, "p", &p);
2097 if (!p) break;
2098
2099 len += tdb_unpack(buf+len, buflen-len, "fdB",
2100 param.value,
2101 &param.type,
2102 &param.data_len,
2103 &param.data);
2104 param.next = *list;
2105 *list = memdup(&param, sizeof(param));
2106
2107 DEBUG(8,("specific: [%s], len: %d\n", param.value, param.data_len));
2108 }
2109
2110 return len;
2111 }
2112
2113
2114 /****************************************************************************
2115 get a default printer info 2 struct
2116 ****************************************************************************/
2117 static uint32 get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharename)
2118 {
2119 extern pstring global_myname;
2120 int snum;
2121 NT_PRINTER_INFO_LEVEL_2 info;
2122
2123 ZERO_STRUCT(info);
2124
2125 snum = lp_servicenumber(sharename);
2126
2127 slprintf(info.servername, sizeof(info.servername), "\\\\%s", global_myname);
2128 slprintf(info.printername, sizeof(info.printername), "\\\\%s\\%s",
2129 global_myname, sharename);
2130 fstrcpy(info.sharename, sharename);
2131 fstrcpy(info.portname, SAMBA_PRINTER_PORT_NAME);
2132 fstrcpy(info.drivername, lp_printerdriver(snum));
2133
2134 if (!*info.drivername)
2135 fstrcpy(info.drivername, "NO DRIVER AVAILABLE FOR THIS PRINTER");
2136
2137 DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info.drivername));
2138
2139 pstrcpy(info.comment, "");
2140 fstrcpy(info.printprocessor, "winprint");
2141 fstrcpy(info.datatype, "RAW");
2142
2143 info.attributes = PRINTER_ATTRIBUTE_SHARED \
2144 | PRINTER_ATTRIBUTE_LOCAL \
2145 | PRINTER_ATTRIBUTE_RAW_ONLY \
2146 | PRINTER_ATTRIBUTE_QUEUED ; /* attributes */
2147
2148 info.starttime = 0; /* Minutes since 12:00am GMT */
2149 info.untiltime = 0; /* Minutes since 12:00am GMT */
2150 info.priority = 1;
2151 info.default_priority = 1;
2152 info.setuptime = (uint32)time(NULL);
2153
2154 if ((info.devmode = construct_nt_devicemode(info.printername)) == NULL)
2155 goto fail;
2156
2157 if (!nt_printing_getsec(sharename, &info.secdesc_buf))
2158 goto fail;
2159
2160 *info_ptr = (NT_PRINTER_INFO_LEVEL_2 *)memdup(&info, sizeof(info));
2161 if (! *info_ptr) {
2162 DEBUG(0,("get_a_printer_2_default: malloc fail.\n"));
2163 goto fail;
2164 }
2165
2166 return (0);
2167
2168 fail:
2169
2170 if (info.devmode)
2171 free_nt_devicemode(&info.devmode);
2172 if (info.secdesc_buf)
2173 free_sec_desc_buf(&info.secdesc_buf);
2174 return 2;
2175 }
2176
2177 /****************************************************************************
2178 ****************************************************************************/
2179 static uint32 get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharename)
2180 {
2181 pstring key;
2182 NT_PRINTER_INFO_LEVEL_2 info;
2183 int len = 0;
2184 TDB_DATA kbuf, dbuf;
2185 fstring printername;
2186
2187 ZERO_STRUCT(info);
2188
2189 slprintf(key, sizeof(key), "%s%s", PRINTERS_PREFIX, sharename);
2190
2191 kbuf.dptr = key;
2192 kbuf.dsize = strlen(key)+1;
2193
2194 dbuf = tdb_fetch(tdb, kbuf);
2195 if (!dbuf.dptr)
2196 return get_a_printer_2_default(info_ptr, sharename);
2197
2198 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "dddddddddddfffffPfffff",
2199 &info.attributes,
2200 &info.priority,
2201 &info.default_priority,
2202 &info.starttime,
2203 &info.untiltime,
2204 &info.status,
2205 &info.cjobs,
2206 &info.averageppm,
2207 &info.changeid,
2208 &info.c_setprinter,
2209 &info.setuptime,
2210 info.servername,
2211 info.printername,
2212 info.sharename,
2213 info.portname,
2214 info.drivername,
2215 info.comment,
2216 info.location,
2217 info.sepfile,
2218 info.printprocessor,
2219 info.datatype,
2220 info.parameters);
2221
2222 /* Samba has to have shared raw drivers. */
2223 info.attributes |= (PRINTER_ATTRIBUTE_SHARED|PRINTER_ATTRIBUTE_RAW_ONLY);
2224
2225 /* Restore the stripped strings. */
2226 slprintf(info.servername, sizeof(info.servername), "\\\\%s", global_myname);
2227 slprintf(printername, sizeof(printername), "\\\\%s\\%s", global_myname,
2228 info.printername);
2229 fstrcpy(info.printername, printername);
2230
2231 len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
2232 len += unpack_specifics(&info.specific,dbuf.dptr+len, dbuf.dsize-len);
2233
2234 nt_printing_getsec(sharename, &info.secdesc_buf);
2235
2236 safe_free(dbuf.dptr);
2237 *info_ptr=memdup(&info, sizeof(info));
2238
2239 DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
2240 sharename, info.printername, info.drivername));
2241
2242
2243 return 0;
2244 }
2245
2246 /****************************************************************************
2247 debugging function, dump at level 6 the struct in the logs
2248 ****************************************************************************/
2249 static uint32 dump_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
2250 {
2251 uint32 result;
2252 NT_PRINTER_INFO_LEVEL_2 *info2;
2253
2254 DEBUG(106,("Dumping printer at level [%d]\n", level));
2255
2256 switch (level)
2257 {
2258 case 2:
2259 {
2260 if (printer.info_2 == NULL)
2261 result=5;
2262 else
2263 {
2264 info2=printer.info_2;
2265
2266 DEBUGADD(106,("attributes:[%d]\n", info2->attributes));
2267 DEBUGADD(106,("priority:[%d]\n", info2->priority));
2268 DEBUGADD(106,("default_priority:[%d]\n", info2->default_priority));
2269 DEBUGADD(106,("starttime:[%d]\n", info2->starttime));
2270 DEBUGADD(106,("untiltime:[%d]\n", info2->untiltime));
2271 DEBUGADD(106,("status:[%d]\n", info2->status));
2272 DEBUGADD(106,("cjobs:[%d]\n", info2->cjobs));
2273 DEBUGADD(106,("averageppm:[%d]\n", info2->averageppm));
2274 DEBUGADD(106,("changeid:[%d]\n", info2->changeid));
2275 DEBUGADD(106,("c_setprinter:[%d]\n", info2->c_setprinter));
2276 DEBUGADD(106,("setuptime:[%d]\n", info2->setuptime));
2277
2278 DEBUGADD(106,("servername:[%s]\n", info2->servername));
2279 DEBUGADD(106,("printername:[%s]\n", info2->printername));
2280 DEBUGADD(106,("sharename:[%s]\n", info2->sharename));
2281 DEBUGADD(106,("portname:[%s]\n", info2->portname));
2282 DEBUGADD(106,("drivername:[%s]\n", info2->drivername));
2283 DEBUGADD(106,("comment:[%s]\n", info2->comment));
2284 DEBUGADD(106,("location:[%s]\n", info2->location));
2285 DEBUGADD(106,("sepfile:[%s]\n", info2->sepfile));
2286 DEBUGADD(106,("printprocessor:[%s]\n", info2->printprocessor));
2287 DEBUGADD(106,("datatype:[%s]\n", info2->datatype));
2288 DEBUGADD(106,("parameters:[%s]\n", info2->parameters));
2289 result=0;
2290 }
2291 break;
2292 }
2293 default:
2294 DEBUGADD(1,("Level not implemented\n"));
2295 result=1;
2296 break;
2297 }
2298
2299 return result;
2300 }
2301
2302 /****************************************************************************
2303 Get the parameters we can substitute in an NT print job.
2304 ****************************************************************************/
2305
2306 void get_printer_subst_params(int snum, fstring *printername, fstring *sharename, fstring *portname)
2307 {
2308 NT_PRINTER_INFO_LEVEL *printer = NULL;
2309
2310 **printername = **sharename = **portname = '\0';
2311
2312 if (get_a_printer(&printer, 2, lp_servicename(snum))!=0)
2313 return;
2314
2315 fstrcpy(*printername, printer->info_2->printername);
2316 fstrcpy(*sharename, printer->info_2->sharename);
2317 fstrcpy(*portname, printer->info_2->portname);
2318
2319 free_a_printer(&printer, 2);
2320 }
2321
2322 /*
2323 * The function below are the high level ones.
2324 * only those ones must be called from the spoolss code.
2325 * JFM.
2326 */
2327
2328 /****************************************************************************
2329 Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
2330 ****************************************************************************/
2331
2332 uint32 mod_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
2333 {
2334 uint32 result;
2335
2336 dump_a_printer(printer, level);
2337
2338 switch (level)
2339 {
2340 case 2:
2341 {
2342 printer.info_2->c_setprinter++;
2343 result=update_a_printer_2(printer.info_2);
2344 break;
2345 }
2346 default:
2347 result=1;
2348 break;
2349 }
2350
2351 return result;
2352 }
2353
2354 /****************************************************************************
2355 Add a printer. This is called from ADDPRINTER(EX) and also SETPRINTER.
2356 We split this out from mod_a_printer as it updates the id's and timestamps.
2357 ****************************************************************************/
2358
2359 uint32 add_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level)
2360 {
2361 uint32 result;
2362
2363 dump_a_printer(printer, level);
2364
2365 switch (level)
2366 {
2367 case 2:
2368 {
2369 /*
2370 * Update the changestamp.
2371 * Note we must *not* do this in mod_a_printer().
2372 */
2373 NTTIME time_nt;
2374 time_t time_unix = time(NULL);
2375 unix_to_nt_time(&time_nt, time_unix);
2376 printer.info_2->changeid=time_nt.low;
2377
2378 printer.info_2->c_setprinter++;
2379 result=update_a_printer_2(printer.info_2);
2380 break;
2381 }
2382 default:
2383 result=1;
2384 break;
2385 }
2386
2387 return result;
2388 }
2389
2390 /****************************************************************************
2391 Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
2392 ****************************************************************************/
2393
2394 uint32 get_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level, fstring sharename)
2395 {
2396 uint32 result;
2397 NT_PRINTER_INFO_LEVEL *printer = NULL;
2398
2399 *pp_printer = NULL;
2400
2401 DEBUG(10,("get_a_printer: [%s] level %u\n", sharename, (unsigned int)level));
2402
2403 switch (level)
2404 {
2405 case 2:
2406 {
2407 if ((printer = (NT_PRINTER_INFO_LEVEL *)malloc(sizeof(NT_PRINTER_INFO_LEVEL))) == NULL) {
2408 DEBUG(0,("get_a_printer: malloc fail.\n"));
2409 return 1;
2410 }
2411 ZERO_STRUCTP(printer);
2412 result=get_a_printer_2(&printer->info_2, sharename);
2413 if (result == 0) {
2414 dump_a_printer(*printer, level);
2415 *pp_printer = printer;
2416 } else {
2417 safe_free(printer);
2418 }
2419 break;
2420 }
2421 default:
2422 result=1;
2423 break;
2424 }
2425
2426 DEBUG(10,("get_a_printer: [%s] level %u returning %u\n", sharename, (unsigned int)level, (unsigned int)result));
2427
2428 return result;
2429 }
2430
2431 /****************************************************************************
2432 Deletes a NT_PRINTER_INFO_LEVEL struct.
2433 ****************************************************************************/
2434
2435 uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level)
2436 {
2437 uint32 result;
2438 NT_PRINTER_INFO_LEVEL *printer = *pp_printer;
2439
2440 DEBUG(104,("freeing a printer at level [%d]\n", level));
2441
2442 if (printer == NULL)
2443 return 0;
2444
2445 switch (level)
2446 {
2447 case 2:
2448 {
2449 if (printer->info_2 != NULL)
2450 {
2451 free_nt_printer_info_level_2(&printer->info_2);
2452 result=0;
2453 }
2454 else
2455 {
2456 result=4;
2457 }
2458 break;
2459 }
2460 default:
2461 result=1;
2462 break;
2463 }
2464
2465 safe_free(printer);
2466 *pp_printer = NULL;
2467 return result;
2468 }
2469
2470 /****************************************************************************
2471 ****************************************************************************/
2472 uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
2473 {
2474 uint32 result;
2475 DEBUG(104,("adding a printer at level [%d]\n", level));
2476 dump_a_printer_driver(driver, level);
2477
2478 switch (level)
2479 {
2480 case 3:
2481 {
2482 result=add_a_printer_driver_3(driver.info_3);
2483 break;
2484 }
2485
2486 case 6:
2487 {
2488 result=add_a_printer_driver_6(driver.info_6);
2489 break;
2490 }
2491 default:
2492 result=1;
2493 break;
2494 }
2495
2496 return result;
2497 }
2498 /****************************************************************************
2499 ****************************************************************************/
2500 uint32 get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level,
2501 fstring printername, fstring architecture, uint32 version)
2502 {
2503 uint32 result;
2504
2505 switch (level)
2506 {
2507 case 3:
2508 {
2509 result=get_a_printer_driver_3(&driver->info_3, printername, architecture, version);
2510 break;
2511 }
2512 default:
2513 result=1;
2514 break;
2515 }
2516
2517 if (result == 0)
2518 dump_a_printer_driver(*driver, level);
2519 return result;
2520 }
2521
2522 /****************************************************************************
2523 ****************************************************************************/
2524 uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
2525 {
2526 uint32 result;
2527
2528 switch (level)
2529 {
2530 case 3:
2531 {
2532 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
2533 if (driver.info_3 != NULL)
2534 {
2535 info3=driver.info_3;
2536 safe_free(info3->dependentfiles);
2537 ZERO_STRUCTP(info3);
2538 safe_free(info3);
2539 result=0;
2540 }
2541 else
2542 {
2543 result=4;
2544 }
2545 break;
2546 }
2547 case 6:
2548 {
2549 NT_PRINTER_DRIVER_INFO_LEVEL_6 *info6;
2550 if (driver.info_6 != NULL)
2551 {
2552 info6=driver.info_6;
2553 safe_free(info6->dependentfiles);
2554 safe_free(info6->previousnames);
2555 ZERO_STRUCTP(info6);
2556 safe_free(info6);
2557 result=0;
2558 }
2559 else
2560 {
2561 result=4;
2562 }
2563 break;
2564 }
2565 default:
2566 result=1;
2567 break;
2568 }
2569 return result;
2570 }
2571
2572 /****************************************************************************
2573 ****************************************************************************/
2574 BOOL get_specific_param_by_index(NT_PRINTER_INFO_LEVEL printer, uint32 level, uint32 param_index,
2575 fstring value, uint8 **data, uint32 *type, uint32 *len)
2576 {
2577 /* right now that's enough ! */
2578 NT_PRINTER_PARAM *param;
2579 int i=0;
2580
2581 param=printer.info_2->specific;
2582
2583 while (param != NULL && i < param_index) {
2584 param=param->next;
2585 i++;
2586 }
2587
2588 if (param == NULL)
2589 return False;
2590
2591 /* exited because it exist */
2592 *type=param->type;
2593 StrnCpy(value, param->value, sizeof(fstring)-1);
2594 *data=(uint8 *)malloc(param->data_len*sizeof(uint8));
2595 if(*data == NULL)
2596 return False;
2597 ZERO_STRUCTP(*data);
2598 memcpy(*data, param->data, param->data_len);
2599 *len=param->data_len;
2600 return True;
2601 }
2602
2603 /****************************************************************************
2604 ****************************************************************************/
2605 BOOL get_specific_param(NT_PRINTER_INFO_LEVEL printer, uint32 level,
2606 fstring value, uint8 **data, uint32 *type, uint32 *len)
2607 {
2608 /* right now that's enough ! */
2609 NT_PRINTER_PARAM *param;
2610
2611 DEBUG(105, ("get_specific_param\n"));
2612
2613 param=printer.info_2->specific;
2614
2615 while (param != NULL)
2616 {
2617 #if 1 /* JRA - I think this should be case insensitive.... */
2618 if ( strequal(value, param->value)
2619 #else
2620 if ( !strcmp(value, param->value)
2621 #endif
2622 && strlen(value)==strlen(param->value))
2623 break;
2624
2625 param=param->next;
2626 }
2627
2628 DEBUG(106, ("found one param\n"));
2629 if (param != NULL)
2630 {
2631 /* exited because it exist */
2632 *type=param->type;
2633
2634 *data=(uint8 *)malloc(param->data_len*sizeof(uint8));
2635 if(*data == NULL)
2636 return False;
2637 memcpy(*data, param->data, param->data_len);
2638 *len=param->data_len;
2639
2640 DEBUG(106, ("exit of get_specific_param:true\n"));
2641 return (True);
2642 }
2643 DEBUG(106, ("exit of get_specific_param:false\n"));
2644 return (False);
2645 }
2646
2647 /****************************************************************************
2648 Store a security desc for a printer.
2649 ****************************************************************************/
2650
2651 uint32 nt_printing_setsec(char *printername, SEC_DESC_BUF *secdesc_ctr)
2652 {
2653 SEC_DESC_BUF *new_secdesc_ctr = NULL;
2654 SEC_DESC_BUF *old_secdesc_ctr = NULL;
2655 prs_struct ps;
2656 TALLOC_CTX *mem_ctx = NULL;
2657 fstring key;
2658 uint32 status;
2659
2660 mem_ctx = talloc_init();
2661 if (mem_ctx == NULL)
2662 return False;
2663
2664 /* The old owner and group sids of the security descriptor are not
2665 present when new ACEs are added or removed by changing printer
2666 permissions through NT. If they are NULL in the new security
2667 descriptor then copy them over from the old one. */
2668
2669 if (!secdesc_ctr->sec->owner_sid || !secdesc_ctr->sec->grp_sid) {
2670 DOM_SID *owner_sid, *group_sid;
2671 SEC_ACL *dacl, *sacl;
2672 SEC_DESC *psd = NULL;
2673 size_t size;
2674
2675 nt_printing_getsec(printername, &old_secdesc_ctr);
2676
2677 /* Pick out correct owner and group sids */
2678
2679 owner_sid = secdesc_ctr->sec->owner_sid ?
2680 secdesc_ctr->sec->owner_sid :
2681 old_secdesc_ctr->sec->owner_sid;
2682
2683 group_sid = secdesc_ctr->sec->grp_sid ?
2684 secdesc_ctr->sec->grp_sid :
2685 old_secdesc_ctr->sec->grp_sid;
2686
2687 dacl = secdesc_ctr->sec->dacl ?
2688 secdesc_ctr->sec->dacl :
2689 old_secdesc_ctr->sec->dacl;
2690
2691 sacl = secdesc_ctr->sec->sacl ?
2692 secdesc_ctr->sec->sacl :
2693 old_secdesc_ctr->sec->sacl;
2694
2695 /* Make a deep copy of the security descriptor */
2696
2697 psd = make_sec_desc(secdesc_ctr->sec->revision,
2698 owner_sid, group_sid,
2699 sacl,
2700 dacl,
2701 &size);
2702
2703 new_secdesc_ctr = make_sec_desc_buf(size, psd);
2704
2705 /* Free up memory */
2706
2707 free_sec_desc(&psd);
2708 free_sec_desc_buf(&old_secdesc_ctr);
2709 }
2710
2711 if (!new_secdesc_ctr) {
2712 new_secdesc_ctr = secdesc_ctr;
2713 }
2714
2715 /* Store the security descriptor in a tdb */
2716
2717 prs_init(&ps, (uint32)sec_desc_size(new_secdesc_ctr->sec) +
2718 sizeof(SEC_DESC_BUF), 4, mem_ctx, MARSHALL);
2719
2720 if (!sec_io_desc_buf("nt_printing_setsec", &new_secdesc_ctr,
2721 &ps, 1)) {
2722 status = ERROR_INVALID_FUNCTION;
2723 goto out;
2724 }
2725
2726 slprintf(key, sizeof(key), "SECDESC/%s", printername);
2727
2728 if (tdb_prs_store(tdb, key, &ps)==0) {
2729 status = 0;
2730 } else {
2731 DEBUG(1,("Failed to store secdesc for %s\n", printername));
2732 status = ERROR_INVALID_FUNCTION;
2733 }
2734
2735 /* Free mallocated memory */
2736
2737 out:
2738 free_sec_desc_buf(&old_secdesc_ctr);
2739
2740 if (new_secdesc_ctr != secdesc_ctr) {
2741 free_sec_desc_buf(&new_secdesc_ctr);
2742 }
2743
2744 prs_mem_free(&ps);
2745 if (mem_ctx)
2746 talloc_destroy(mem_ctx);
2747 return status;
2748 }
2749
2750 /****************************************************************************
2751 Construct a default security descriptor buffer for a printer.
2752 ****************************************************************************/
2753
2754 static SEC_DESC_BUF *construct_default_printer_sdb(void)
2755 {
2756 SEC_ACE ace[3];
2757 SEC_ACCESS sa;
2758 SEC_ACL *psa = NULL;
2759 SEC_DESC_BUF *sdb = NULL;
2760 SEC_DESC *psd = NULL;
2761 DOM_SID owner_sid;
2762 size_t sd_size;
2763 enum SID_NAME_USE name_type;
2764
2765 /* Create an ACE where Everyone is allowed to print */
2766
2767 init_sec_access(&sa, PRINTER_ACE_PRINT);
2768 init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
2769 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
2770
2771 /* Make the security descriptor owned by the Administrators group
2772 on the PDC of the domain. */
2773
2774 if (winbind_lookup_name(lp_workgroup(), &owner_sid, &name_type)) {
2775 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
2776 } else {
2777
2778 /* Backup plan - make printer owned by admins or root. This should
2779 emulate a lanman printer as security settings can't be
2780 changed. */
2781
2782 if (!lookup_name( "Printer Administrators", &owner_sid, &name_type) &&
2783 !lookup_name( "Administrators", &owner_sid, &name_type) &&
2784 !lookup_name( "Administrator", &owner_sid, &name_type) &&
2785 !lookup_name("root", &owner_sid, &name_type)) {
2786 sid_copy(&owner_sid, &global_sid_World);
2787 }
2788 }
2789
2790 init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
2791 init_sec_ace(&ace[1], &owner_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
2792 sa, SEC_ACE_FLAG_OBJECT_INHERIT |
2793 SEC_ACE_FLAG_INHERIT_ONLY);
2794
2795 init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
2796 init_sec_ace(&ace[2], &owner_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
2797 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
2798
2799 /* The ACL revision number in rpc_secdesc.h differs from the one
2800 created by NT when setting ACE entries in printer
2801 descriptors. NT4 complains about the property being edited by a
2802 NT5 machine. */
2803
2804 #define NT4_ACL_REVISION 0x2
2805
2806 if ((psa = make_sec_acl(NT4_ACL_REVISION, 3, ace)) != NULL) {
2807 psd = make_sec_desc(SEC_DESC_REVISION,
2808 &owner_sid, NULL,
2809 NULL, psa, &sd_size);
2810 free_sec_acl(&psa);
2811 }
2812
2813 if (!psd) {
2814 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
2815 return NULL;
2816 }
2817
2818 sdb = make_sec_desc_buf(sd_size, psd);
2819
2820 DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
2821 (unsigned int)sd_size));
2822
2823 free_sec_desc(&psd);
2824 return sdb;
2825 }
2826
2827 /****************************************************************************
2828 Get a security desc for a printer.
2829 ****************************************************************************/
2830
2831 BOOL nt_printing_getsec(char *printername, SEC_DESC_BUF **secdesc_ctr)
2832 {
2833 prs_struct ps;
2834 TALLOC_CTX *mem_ctx = NULL;
2835 fstring key;
2836
2837 mem_ctx = talloc_init();
2838 if (mem_ctx == NULL)
2839 return False;
2840
2841 /* Fetch security descriptor from tdb */
2842
2843 slprintf(key, sizeof(key), "SECDESC/%s", printername);
2844
2845 if (tdb_prs_fetch(tdb, key, &ps, mem_ctx)!=0 ||
2846 !sec_io_desc_buf("nt_printing_getsec", secdesc_ctr, &ps, 1)) {
2847
2848 DEBUG(4,("using default secdesc for %s\n", printername));
2849
2850 if (!(*secdesc_ctr = construct_default_printer_sdb())) {
2851 talloc_destroy(mem_ctx);
2852 return False;
2853 }
2854
2855 talloc_destroy(mem_ctx);
2856 return True;
2857 }
2858
2859 /* If security descriptor is owned by S-1-1-0 and winbindd is up,
2860 this security descriptor has been created when winbindd was
2861 down. Take ownership of security descriptor. */
2862
2863 if (sid_equal((*secdesc_ctr)->sec->owner_sid, &global_sid_World)) {
2864 DOM_SID owner_sid;
2865 enum SID_NAME_USE name_type;
2866
2867 /* Change sd owner to workgroup administrator */
2868
2869 if (winbind_lookup_name(lp_workgroup(), &owner_sid,
2870 &name_type)) {
2871 SEC_DESC_BUF *new_secdesc_ctr = NULL;
2872 SEC_DESC *psd = NULL;
2873 size_t size;
2874
2875 /* Create new sd */
2876
2877 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
2878
2879 psd = make_sec_desc((*secdesc_ctr)->sec->revision,
2880 &owner_sid,
2881 (*secdesc_ctr)->sec->grp_sid,
2882 (*secdesc_ctr)->sec->sacl,
2883 (*secdesc_ctr)->sec->dacl,
2884 &size);
2885
2886 new_secdesc_ctr = make_sec_desc_buf(size, psd);
2887
2888 free_sec_desc(&psd);
2889
2890 /* Swap with other one */
2891
2892 free_sec_desc_buf(secdesc_ctr);
2893 *secdesc_ctr = new_secdesc_ctr;
2894
2895 /* Set it */
2896
2897 nt_printing_setsec(printername, *secdesc_ctr);
2898 }
2899 }
2900
2901 if (DEBUGLEVEL >= 10) {
2902 SEC_ACL *acl = (*secdesc_ctr)->sec->dacl;
2903 int i;
2904
2905 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
2906 printername, acl->num_aces));
2907
2908 for (i = 0; i < acl->num_aces; i++) {
2909 fstring sid_str;
2910
2911 sid_to_string(sid_str, &acl->ace[i].sid);
2912
2913 DEBUG(10, ("%s 0x%08x\n", sid_str,
2914 acl->ace[i].info.mask));
2915 }
2916 }
2917
2918 prs_mem_free(&ps);
2919 talloc_destroy(mem_ctx);
2920 return True;
2921 }
2922
2923 /* error code:
2924 0: everything OK
2925 1: level not implemented
2926 2: file doesn't exist
2927 3: can't allocate memory
2928 4: can't free memory
2929 5: non existant struct
2930 */
2931
2932 /*
2933 A printer and a printer driver are 2 different things.
2934 NT manages them separatelly, Samba does the same.
2935 Why ? Simply because it's easier and it makes sense !
2936
2937 Now explanation: You have 3 printers behind your samba server,
2938 2 of them are the same make and model (laser A and B). But laser B
2939 has an 3000 sheet feeder and laser A doesn't such an option.
2940 Your third printer is an old dot-matrix model for the accounting :-).
2941
2942 If the /usr/local/samba/lib directory (default dir), you will have
2943 5 files to describe all of this.
2944
2945 3 files for the printers (1 by printer):
2946 NTprinter_laser A
2947 NTprinter_laser B
2948 NTprinter_accounting
2949 2 files for the drivers (1 for the laser and 1 for the dot matrix)
2950 NTdriver_printer model X
2951 NTdriver_printer model Y
2952
2953 jfm: I should use this comment for the text file to explain
2954 same thing for the forms BTW.
2955 Je devrais mettre mes commentaires en francais, ca serait mieux :-)
2956
2957 */
2958
2959 /****************************************************************************
2960 Check a user has permissions to perform the given operation. We use some
2961 constants defined in include/rpc_spoolss.h that look relevant to check
2962 the various actions we perform when checking printer access.
2963
2964 PRINTER_ACCESS_ADMINISTER:
2965 print_queue_pause, print_queue_resume, update_printer_sec,
2966 update_printer, spoolss_addprinterex_level_2,
2967 _spoolss_setprinterdata
2968
2969 PRINTER_ACCESS_USE:
2970 print_job_start
2971
2972 JOB_ACCESS_ADMINISTER:
2973 print_job_delete, print_job_pause, print_job_resume,
2974 print_queue_purge
2975
2976 ****************************************************************************/
2977 BOOL print_access_check(struct current_user *user, int snum, int access_type)
2978 {
2979 SEC_DESC_BUF *secdesc = NULL;
2980 uint32 access_granted, status, required_access = 0;
2981 BOOL result;
2982 char *pname;
2983 extern struct current_user current_user;
2984
2985 /* If user is NULL then use the current_user structure */
2986
2987 if (!user) user = &current_user;
2988
2989 /* Always allow root or printer admins to do anything */
2990
2991 if (user->uid == 0 ||
2992 user_in_list(uidtoname(user->uid), lp_printer_admin(snum))) {
2993 return True;
2994 }
2995
2996 /* Get printer name */
2997
2998 pname = PRINTERNAME(snum);
2999
3000 if (!pname || !*pname)
3001 pname = SERVICE(snum);
3002
3003 if (!pname || !*pname) {
3004 errno = EACCES;
3005 return False;
3006 }
3007
3008 /* Get printer security descriptor */
3009
3010 nt_printing_getsec(pname, &secdesc);
3011
3012 /* Check against NT4 ACE mask values. From observation these
3013 values are:
3014
3015 Access Type ACE Mask Constant
3016 -------------------------------------
3017 Full Control 0x10000000 PRINTER_ACE_FULL_CONTROL
3018 Print 0xe0000000 PRINTER_ACE_PRINT
3019 Manage Documents 0x00020000 PRINTER_ACE_MANAGE_DOCUMENTS
3020 */
3021
3022 switch (access_type) {
3023 case PRINTER_ACCESS_USE:
3024 required_access = PRINTER_ACE_PRINT;
3025 break;
3026 case PRINTER_ACCESS_ADMINISTER:
3027 /*
3028 * This should be set to PRINTER_ACE_FULL_CONTROL, not to
3029 * (PRINTER_ACE_PRINT | PRINTER_ACE_MANAGE_DOCUMENTS).
3030 * Doing the latter gives anyone with both PRINTER_ACE_PRINT
3031 * and PRINTER_ACE_MANAGE_DOCUMENTS (in any combination of ACLs)
3032 * full control over all printer functions. This isn't what
3033 * we want.
3034 */
3035 required_access = PRINTER_ACE_FULL_CONTROL;
3036 break;
3037 case JOB_ACCESS_ADMINISTER:
3038 required_access = PRINTER_ACE_MANAGE_DOCUMENTS;
3039 break;
3040 default:
3041 DEBUG(0, ("invalid value passed to print_access_check()\n"));
3042 result = False;
3043 goto done;
3044 }
3045
3046 if ((result = se_access_check(secdesc->sec, user, required_access,
3047 &access_granted, &status))) {
3048 goto done;
3049 }
3050
3051 /* Check against NT5 ACE mask values. From observation these
3052 values are:
3053
3054 Access Type ACE Mask Constant
3055 -------------------------------------
3056 Full Control 0x000f000c PRINTER_ACE_NT5_FULL_CONTROL
3057 Print 0x00020008 PRINTER_ACE_NT5_PRINT
3058 Manage Documents 0x00020000 PRINTER_ACE_NT5_MANAGE_DOCUMENTS
3059
3060 NT5 likes to rewrite the security descriptor and change the ACE
3061 masks from NT4 format to NT5 format making them unreadable by
3062 NT4 clients. */
3063
3064 switch (access_type) {
3065 case PRINTER_ACCESS_USE:
3066 required_access = PRINTER_ACE_NT5_PRINT;
3067 break;
3068 case PRINTER_ACCESS_ADMINISTER:
3069 required_access = PRINTER_ACE_NT5_FULL_CONTROL;
3070 break;
3071 case JOB_ACCESS_ADMINISTER:
3072 required_access = PRINTER_ACE_NT5_MANAGE_DOCUMENTS;
3073 break;
3074 }
3075
3076 result = se_access_check(secdesc->sec, user, required_access,
3077 &access_granted, &status);
3078
3079 /* Check access */
3080
3081 done:
3082 DEBUG(4, ("access check was %s\n", result ? "SUCCESS" : "FAILURE"));
3083
3084 /* Free mallocated memory */
3085
3086 free_sec_desc_buf(&secdesc);
3087
3088 if (!result)
3089 errno = EACCES;
3090
3091 return result;
3092 }
3093
3094 /****************************************************************************
3095 Check the time parameters allow a print operation.
3096 *****************************************************************************/
3097
3098 BOOL print_time_access_check(int snum)
3099 {
3100 NT_PRINTER_INFO_LEVEL *printer = NULL;
3101 BOOL ok = False;
3102 time_t now = time(NULL);
3103 struct tm *t;
3104 uint32 mins;
3105
3106 if (get_a_printer(&printer, 2, lp_servicename(snum))!=0)
3107 return False;
3108
3109 if (printer->info_2->starttime == 0 && printer->info_2->untiltime == 0)
3110 ok = True;
3111
3112 t = gmtime(&now);
3113 mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
3114
3115 if (mins >= printer->info_2->starttime && mins <= printer->info_2->untiltime)
3116 ok = True;
3117
3118 free_a_printer(&printer, 2);
3119
3120 if (!ok)
3121 errno = EACCES;
3122
3123 return ok;
3124 }
3125
3126
3127 #undef OLD_NTDOMAIN
Samba GIT mirror