2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Jean François Micouleau 1998-2000.
6 * Copyright (C) Gerald Carter 2002-2005.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 extern struct current_user current_user
;
27 static TDB_CONTEXT
*tdb_forms
; /* used for forms files */
28 static TDB_CONTEXT
*tdb_drivers
; /* used for driver files */
29 static TDB_CONTEXT
*tdb_printers
; /* used for printers files */
31 #define FORMS_PREFIX "FORMS/"
32 #define DRIVERS_PREFIX "DRIVERS/"
33 #define DRIVER_INIT_PREFIX "DRIVER_INIT/"
34 #define PRINTERS_PREFIX "PRINTERS/"
35 #define SECDESC_PREFIX "SECDESC/"
36 #define GLOBAL_C_SETPRINTER "GLOBALS/c_setprinter"
38 #define NTDRIVERS_DATABASE_VERSION_1 1
39 #define NTDRIVERS_DATABASE_VERSION_2 2
40 #define NTDRIVERS_DATABASE_VERSION_3 3 /* little endian version of v2 */
41 #define NTDRIVERS_DATABASE_VERSION_4 4 /* fix generic bits in security descriptors */
42 #define NTDRIVERS_DATABASE_VERSION_5 5 /* normalize keys in ntprinters.tdb */
44 /* Map generic permissions to printer object specific permissions */
46 GENERIC_MAPPING printer_generic_mapping
= {
53 STANDARD_MAPPING printer_std_mapping
= {
60 /* Map generic permissions to print server object specific permissions */
62 GENERIC_MAPPING printserver_generic_mapping
= {
69 STANDARD_MAPPING printserver_std_mapping
= {
76 /* We need one default form to support our default printer. Msoft adds the
77 forms it wants and in the ORDER it wants them (note: DEVMODE papersize is an
78 array index). Letter is always first, so (for the current code) additions
79 always put things in the correct order. */
80 static const nt_forms_struct default_forms
[] = {
81 {"Letter",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
82 {"Letter Small",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
83 {"Tabloid",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
84 {"Ledger",0x1,0x696b8,0x44368,0x0,0x0,0x696b8,0x44368},
85 {"Legal",0x1,0x34b5c,0x56d10,0x0,0x0,0x34b5c,0x56d10},
86 {"Statement",0x1,0x221b4,0x34b5c,0x0,0x0,0x221b4,0x34b5c},
87 {"Executive",0x1,0x2cf56,0x411cc,0x0,0x0,0x2cf56,0x411cc},
88 {"A3",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
89 {"A4",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
90 {"A4 Small",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
91 {"A5",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
92 {"B4 (JIS)",0x1,0x3ebe8,0x58de0,0x0,0x0,0x3ebe8,0x58de0},
93 {"B5 (JIS)",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
94 {"Folio",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
95 {"Quarto",0x1,0x347d8,0x43238,0x0,0x0,0x347d8,0x43238},
96 {"10x14",0x1,0x3e030,0x56d10,0x0,0x0,0x3e030,0x56d10},
97 {"11x17",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
98 {"Note",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
99 {"Envelope #9",0x1,0x18079,0x37091,0x0,0x0,0x18079,0x37091},
100 {"Envelope #10",0x1,0x19947,0x3ae94,0x0,0x0,0x19947,0x3ae94},
101 {"Envelope #11",0x1,0x1be7c,0x40565,0x0,0x0,0x1be7c,0x40565},
102 {"Envelope #12",0x1,0x1d74a,0x44368,0x0,0x0,0x1d74a,0x44368},
103 {"Envelope #14",0x1,0x1f018,0x47504,0x0,0x0,0x1f018,0x47504},
104 {"C size sheet",0x1,0x696b8,0x886d0,0x0,0x0,0x696b8,0x886d0},
105 {"D size sheet",0x1,0x886d0,0xd2d70,0x0,0x0,0x886d0,0xd2d70},
106 {"E size sheet",0x1,0xd2d70,0x110da0,0x0,0x0,0xd2d70,0x110da0},
107 {"Envelope DL",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
108 {"Envelope C5",0x1,0x278d0,0x37e88,0x0,0x0,0x278d0,0x37e88},
109 {"Envelope C3",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
110 {"Envelope C4",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
111 {"Envelope C6",0x1,0x1bd50,0x278d0,0x0,0x0,0x1bd50,0x278d0},
112 {"Envelope C65",0x1,0x1bd50,0x37e88,0x0,0x0,0x1bd50,0x37e88},
113 {"Envelope B4",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
114 {"Envelope B5",0x1,0x2af80,0x3d090,0x0,0x0,0x2af80,0x3d090},
115 {"Envelope B6",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
116 {"Envelope",0x1,0x1adb0,0x38270,0x0,0x0,0x1adb0,0x38270},
117 {"Envelope Monarch",0x1,0x18079,0x2e824,0x0,0x0,0x18079,0x2e824},
118 {"6 3/4 Envelope",0x1,0x167ab,0x284ec,0x0,0x0,0x167ab,0x284ec},
119 {"US Std Fanfold",0x1,0x5c3e1,0x44368,0x0,0x0,0x5c3e1,0x44368},
120 {"German Std Fanfold",0x1,0x34b5c,0x4a6a0,0x0,0x0,0x34b5c,0x4a6a0},
121 {"German Legal Fanfold",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
122 {"B4 (ISO)",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
123 {"Japanese Postcard",0x1,0x186a0,0x24220,0x0,0x0,0x186a0,0x24220},
124 {"9x11",0x1,0x37cf8,0x44368,0x0,0x0,0x37cf8,0x44368},
125 {"10x11",0x1,0x3e030,0x44368,0x0,0x0,0x3e030,0x44368},
126 {"15x11",0x1,0x5d048,0x44368,0x0,0x0,0x5d048,0x44368},
127 {"Envelope Invite",0x1,0x35b60,0x35b60,0x0,0x0,0x35b60,0x35b60},
128 {"Reserved48",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
129 {"Reserved49",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
130 {"Letter Extra",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
131 {"Legal Extra",0x1,0x3ae94,0x5d048,0x0,0x0,0x3ae94,0x5d048},
132 {"Tabloid Extra",0x1,0x4a6a0,0x6f9f0,0x0,0x0,0x4a6a0,0x6f9f0},
133 {"A4 Extra",0x1,0x397c2,0x4eb16,0x0,0x0,0x397c2,0x4eb16},
134 {"Letter Transverse",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
135 {"A4 Transverse",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
136 {"Letter Extra Transverse",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
137 {"Super A",0x1,0x376b8,0x56ea0,0x0,0x0,0x376b8,0x56ea0},
138 {"Super B",0x1,0x4a768,0x76e58,0x0,0x0,0x4a768,0x76e58},
139 {"Letter Plus",0x1,0x34b5c,0x4eb16,0x0,0x0,0x34b5c,0x4eb16},
140 {"A4 Plus",0x1,0x33450,0x50910,0x0,0x0,0x33450,0x50910},
141 {"A5 Transverse",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
142 {"B5 (JIS) Transverse",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
143 {"A3 Extra",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
144 {"A5 Extra",0x1,0x2a7b0,0x395f8,0x0,0x0,0x2a7b0,0x395f8},
145 {"B5 (ISO) Extra",0x1,0x31128,0x43620,0x0,0x0,0x31128,0x43620},
146 {"A2",0x1,0x668a0,0x91050,0x0,0x0,0x668a0,0x91050},
147 {"A3 Transverse",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
148 {"A3 Extra Transverse",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
149 {"Japanese Double Postcard",0x1,0x30d40,0x24220,0x0,0x0,0x30d40,0x24220},
150 {"A6",0x1,0x19a28,0x24220,0x0,0x0,0x19a28,0x24220},
151 {"Japanese Envelope Kaku #2",0x1,0x3a980,0x510e0,0x0,0x0,0x3a980,0x510e0},
152 {"Japanese Envelope Kaku #3",0x1,0x34bc0,0x43a08,0x0,0x0,0x34bc0,0x43a08},
153 {"Japanese Envelope Chou #3",0x1,0x1d4c0,0x395f8,0x0,0x0,0x1d4c0,0x395f8},
154 {"Japanese Envelope Chou #4",0x1,0x15f90,0x320c8,0x0,0x0,0x15f90,0x320c8},
155 {"Letter Rotated",0x1,0x44368,0x34b5c,0x0,0x0,0x44368,0x34b5c},
156 {"A3 Rotated",0x1,0x668a0,0x48828,0x0,0x0,0x668a0,0x48828},
157 {"A4 Rotated",0x1,0x48828,0x33450,0x0,0x0,0x48828,0x33450},
158 {"A5 Rotated",0x1,0x33450,0x24220,0x0,0x0,0x33450,0x24220},
159 {"B4 (JIS) Rotated",0x1,0x58de0,0x3ebe8,0x0,0x0,0x58de0,0x3ebe8},
160 {"B5 (JIS) Rotated",0x1,0x3ebe8,0x2c6f0,0x0,0x0,0x3ebe8,0x2c6f0},
161 {"Japanese Postcard Rotated",0x1,0x24220,0x186a0,0x0,0x0,0x24220,0x186a0},
162 {"Double Japan Postcard Rotated",0x1,0x24220,0x30d40,0x0,0x0,0x24220,0x30d40},
163 {"A6 Rotated",0x1,0x24220,0x19a28,0x0,0x0,0x24220,0x19a28},
164 {"Japan Envelope Kaku #2 Rotated",0x1,0x510e0,0x3a980,0x0,0x0,0x510e0,0x3a980},
165 {"Japan Envelope Kaku #3 Rotated",0x1,0x43a08,0x34bc0,0x0,0x0,0x43a08, 0x34bc0},
166 {"Japan Envelope Chou #3 Rotated",0x1,0x395f8,0x1d4c0,0x0,0x0,0x395f8,0x1d4c0},
167 {"Japan Envelope Chou #4 Rotated",0x1,0x320c8,0x15f90,0x0,0x0,0x320c8,0x15f90},
168 {"B6 (JIS)",0x1,0x1f400,0x2c6f0,0x0,0x0,0x1f400,0x2c6f0},
169 {"B6 (JIS) Rotated",0x1,0x2c6f0,0x1f400,0x0,0x0,0x2c6f0,0x1f400},
170 {"12x11",0x1,0x4a724,0x443e1,0x0,0x0,0x4a724,0x443e1},
171 {"Japan Envelope You #4",0x1,0x19a28,0x395f8,0x0,0x0,0x19a28,0x395f8},
172 {"Japan Envelope You #4 Rotated",0x1,0x395f8,0x19a28,0x0,0x0,0x395f8,0x19a28},
173 {"PRC 16K",0x1,0x2de60,0x3f7a0,0x0,0x0,0x2de60,0x3f7a0},
174 {"PRC 32K",0x1,0x1fbd0,0x2cec0,0x0,0x0,0x1fbd0,0x2cec0},
175 {"PRC 32K(Big)",0x1,0x222e0,0x318f8,0x0,0x0,0x222e0,0x318f8},
176 {"PRC Envelope #1",0x1,0x18e70,0x28488,0x0,0x0,0x18e70,0x28488},
177 {"PRC Envelope #2",0x1,0x18e70,0x2af80,0x0,0x0,0x18e70,0x2af80},
178 {"PRC Envelope #3",0x1,0x1e848,0x2af80,0x0,0x0,0x1e848,0x2af80},
179 {"PRC Envelope #4",0x1,0x1adb0,0x32c80,0x0,0x0,0x1adb0,0x32c80},
180 {"PRC Envelope #5",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
181 {"PRC Envelope #6",0x1,0x1d4c0,0x38270,0x0,0x0,0x1d4c0,0x38270},
182 {"PRC Envelope #7",0x1,0x27100,0x38270,0x0,0x0,0x27100,0x38270},
183 {"PRC Envelope #8",0x1,0x1d4c0,0x4b708,0x0,0x0,0x1d4c0,0x4b708},
184 {"PRC Envelope #9",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
185 {"PRC Envelope #10",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
186 {"PRC 16K Rotated",0x1,0x3f7a0,0x2de60,0x0,0x0,0x3f7a0,0x2de60},
187 {"PRC 32K Rotated",0x1,0x2cec0,0x1fbd0,0x0,0x0,0x2cec0,0x1fbd0},
188 {"PRC 32K(Big) Rotated",0x1,0x318f8,0x222e0,0x0,0x0,0x318f8,0x222e0},
189 {"PRC Envelope #1 Rotated",0x1,0x28488,0x18e70,0x0,0x0,0x28488,0x18e70},
190 {"PRC Envelope #2 Rotated",0x1,0x2af80,0x18e70,0x0,0x0,0x2af80,0x18e70},
191 {"PRC Envelope #3 Rotated",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
192 {"PRC Envelope #4 Rotated",0x1,0x32c80,0x1adb0,0x0,0x0,0x32c80,0x1adb0},
193 {"PRC Envelope #5 Rotated",0x1,0x35b60,0x1adb0,0x0,0x0,0x35b60,0x1adb0},
194 {"PRC Envelope #6 Rotated",0x1,0x38270,0x1d4c0,0x0,0x0,0x38270,0x1d4c0},
195 {"PRC Envelope #7 Rotated",0x1,0x38270,0x27100,0x0,0x0,0x38270,0x27100},
196 {"PRC Envelope #8 Rotated",0x1,0x4b708,0x1d4c0,0x0,0x0,0x4b708,0x1d4c0},
197 {"PRC Envelope #9 Rotated",0x1,0x4f1a0,0x37e88,0x0,0x0,0x4f1a0,0x37e88},
198 {"PRC Envelope #10 Rotated",0x1,0x6fd10,0x4f1a0,0x0,0x0,0x6fd10,0x4f1a0}
202 const char *long_archi
;
203 const char *short_archi
;
207 #define SPL_ARCH_WIN40 "WIN40"
208 #define SPL_ARCH_W32X86 "W32X86"
209 #define SPL_ARCH_W32MIPS "W32MIPS"
210 #define SPL_ARCH_W32ALPHA "W32ALPHA"
211 #define SPL_ARCH_W32PPC "W32PPC"
212 #define SPL_ARCH_IA64 "IA64"
213 #define SPL_ARCH_X64 "x64"
215 static const struct table_node archi_table
[]= {
217 {"Windows 4.0", SPL_ARCH_WIN40
, 0 },
218 {"Windows NT x86", SPL_ARCH_W32X86
, 2 },
219 {"Windows NT R4000", SPL_ARCH_W32MIPS
, 2 },
220 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA
, 2 },
221 {"Windows NT PowerPC", SPL_ARCH_W32PPC
, 2 },
222 {"Windows IA64", SPL_ARCH_IA64
, 3 },
223 {"Windows x64", SPL_ARCH_X64
, 3 },
228 /****************************************************************************
229 generate a new TDB_DATA key for storing a printer
230 ****************************************************************************/
232 static TDB_DATA
make_printer_tdbkey( const char *sharename
)
235 static pstring keystr
;
238 fstrcpy( share
, sharename
);
241 pstr_sprintf( keystr
, "%s%s", PRINTERS_PREFIX
, share
);
244 key
.dsize
= strlen(keystr
)+1;
249 /****************************************************************************
250 generate a new TDB_DATA key for storing a printer security descriptor
251 ****************************************************************************/
253 static char *make_printers_secdesc_tdbkey( const char* sharename
)
256 static pstring keystr
;
258 fstrcpy( share
, sharename
);
261 pstr_sprintf( keystr
, "%s%s", SECDESC_PREFIX
, share
);
266 /****************************************************************************
267 ****************************************************************************/
269 static BOOL
upgrade_to_version_3(void)
271 TDB_DATA kbuf
, newkey
, dbuf
;
273 DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n"));
275 for (kbuf
= tdb_firstkey(tdb_drivers
); kbuf
.dptr
;
276 newkey
= tdb_nextkey(tdb_drivers
, kbuf
), safe_free(kbuf
.dptr
), kbuf
=newkey
) {
278 dbuf
= tdb_fetch(tdb_drivers
, kbuf
);
280 if (strncmp(kbuf
.dptr
, FORMS_PREFIX
, strlen(FORMS_PREFIX
)) == 0) {
281 DEBUG(0,("upgrade_to_version_3:moving form\n"));
282 if (tdb_store(tdb_forms
, kbuf
, dbuf
, TDB_REPLACE
) != 0) {
283 SAFE_FREE(dbuf
.dptr
);
284 DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms
)));
287 if (tdb_delete(tdb_drivers
, kbuf
) != 0) {
288 SAFE_FREE(dbuf
.dptr
);
289 DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers
)));
294 if (strncmp(kbuf
.dptr
, PRINTERS_PREFIX
, strlen(PRINTERS_PREFIX
)) == 0) {
295 DEBUG(0,("upgrade_to_version_3:moving printer\n"));
296 if (tdb_store(tdb_printers
, kbuf
, dbuf
, TDB_REPLACE
) != 0) {
297 SAFE_FREE(dbuf
.dptr
);
298 DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers
)));
301 if (tdb_delete(tdb_drivers
, kbuf
) != 0) {
302 SAFE_FREE(dbuf
.dptr
);
303 DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers
)));
308 if (strncmp(kbuf
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
)) == 0) {
309 DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
310 if (tdb_store(tdb_printers
, kbuf
, dbuf
, TDB_REPLACE
) != 0) {
311 SAFE_FREE(dbuf
.dptr
);
312 DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers
)));
315 if (tdb_delete(tdb_drivers
, kbuf
) != 0) {
316 SAFE_FREE(dbuf
.dptr
);
317 DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers
)));
322 SAFE_FREE(dbuf
.dptr
);
328 /*******************************************************************
329 Fix an issue with security descriptors. Printer sec_desc must
330 use more than the generic bits that were previously used
331 in <= 3.0.14a. They must also have a owner and group SID assigned.
332 Otherwise, any printers than have been migrated to a Windows
333 host using printmig.exe will not be accessible.
334 *******************************************************************/
336 static int sec_desc_upg_fn( TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
337 TDB_DATA data
, void *state
)
340 SEC_DESC_BUF
*sd_orig
= NULL
;
341 SEC_DESC_BUF
*sd_new
, *sd_store
;
342 SEC_DESC
*sec
, *new_sec
;
343 TALLOC_CTX
*ctx
= state
;
349 if (!data
.dptr
|| data
.dsize
== 0) {
353 if ( strncmp( key
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
) ) != 0 ) {
357 /* upgrade the security descriptor */
361 prs_init( &ps
, 0, ctx
, UNMARSHALL
);
362 prs_give_memory( &ps
, data
.dptr
, data
.dsize
, False
);
364 if ( !sec_io_desc_buf( "sec_desc_upg_fn", &sd_orig
, &ps
, 1 ) ) {
365 /* delete bad entries */
366 DEBUG(0,("sec_desc_upg_fn: Failed to parse original sec_desc for %si. Deleting....\n", key
.dptr
));
367 tdb_delete( tdb_printers
, key
);
378 /* is this even valid? */
385 /* update access masks */
387 for ( i
=0; i
<sec
->dacl
->num_aces
; i
++ ) {
388 switch ( sec
->dacl
->aces
[i
].access_mask
) {
389 case (GENERIC_READ_ACCESS
| GENERIC_WRITE_ACCESS
| GENERIC_EXECUTE_ACCESS
):
390 sec
->dacl
->aces
[i
].access_mask
= PRINTER_ACE_PRINT
;
393 case GENERIC_ALL_ACCESS
:
394 sec
->dacl
->aces
[i
].access_mask
= PRINTER_ACE_FULL_CONTROL
;
397 case READ_CONTROL_ACCESS
:
398 sec
->dacl
->aces
[i
].access_mask
= PRINTER_ACE_MANAGE_DOCUMENTS
;
400 default: /* no change */
405 /* create a new SEC_DESC with the appropriate owner and group SIDs */
407 string_to_sid(&sid
, "S-1-5-32-544" );
408 new_sec
= make_sec_desc( ctx
, SEC_DESC_REVISION
, SEC_DESC_SELF_RELATIVE
,
410 NULL
, NULL
, &size_new_sec
);
415 sd_new
= make_sec_desc_buf( ctx
, size_new_sec
, new_sec
);
421 if ( !(sd_store
= sec_desc_merge( ctx
, sd_new
, sd_orig
)) ) {
422 DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key
.dptr
));
431 sd_size
= sec_desc_size(sd_store
->sec
) + sizeof(SEC_DESC_BUF
);
432 prs_init(&ps
, sd_size
, ctx
, MARSHALL
);
434 if ( !sec_io_desc_buf( "sec_desc_upg_fn", &sd_store
, &ps
, 1 ) ) {
435 DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key
.dptr
));
440 data
.dptr
= prs_data_p( &ps
);
441 data
.dsize
= sd_size
;
443 result
= tdb_store( tdb_printers
, key
, data
, TDB_REPLACE
);
447 /* 0 to continue and non-zero to stop traversal */
449 return (result
== -1);
452 /*******************************************************************
453 *******************************************************************/
455 static BOOL
upgrade_to_version_4(void)
460 DEBUG(0,("upgrade_to_version_4: upgrading printer security descriptors\n"));
462 if ( !(ctx
= talloc_init( "upgrade_to_version_4" )) )
465 result
= tdb_traverse( tdb_printers
, sec_desc_upg_fn
, ctx
);
467 talloc_destroy( ctx
);
469 return ( result
!= -1 );
472 /*******************************************************************
473 Fix an issue with security descriptors. Printer sec_desc must
474 use more than the generic bits that were previously used
475 in <= 3.0.14a. They must also have a owner and group SID assigned.
476 Otherwise, any printers than have been migrated to a Windows
477 host using printmig.exe will not be accessible.
478 *******************************************************************/
480 static int normalize_printers_fn( TDB_CONTEXT
*the_tdb
, TDB_DATA key
,
481 TDB_DATA data
, void *state
)
485 if (!data
.dptr
|| data
.dsize
== 0)
488 /* upgrade printer records and security descriptors */
490 if ( strncmp( key
.dptr
, PRINTERS_PREFIX
, strlen(PRINTERS_PREFIX
) ) == 0 ) {
491 new_key
= make_printer_tdbkey( key
.dptr
+strlen(PRINTERS_PREFIX
) );
493 else if ( strncmp( key
.dptr
, SECDESC_PREFIX
, strlen(SECDESC_PREFIX
) ) == 0 ) {
494 new_key
.dptr
= make_printers_secdesc_tdbkey( key
.dptr
+strlen(SECDESC_PREFIX
) );
495 new_key
.dsize
= strlen( new_key
.dptr
) + 1;
498 /* ignore this record */
502 /* delete the original record and store under the normalized key */
504 if ( tdb_delete( the_tdb
, key
) != 0 ) {
505 DEBUG(0,("normalize_printers_fn: tdb_delete for [%s] failed!\n",
510 if ( tdb_store( the_tdb
, new_key
, data
, TDB_REPLACE
) != 0 ) {
511 DEBUG(0,("normalize_printers_fn: failed to store new record for [%s]!\n",
519 /*******************************************************************
520 *******************************************************************/
522 static BOOL
upgrade_to_version_5(void)
527 DEBUG(0,("upgrade_to_version_5: normalizing printer keys\n"));
529 if ( !(ctx
= talloc_init( "upgrade_to_version_5" )) )
532 result
= tdb_traverse( tdb_printers
, normalize_printers_fn
, NULL
);
534 talloc_destroy( ctx
);
536 return ( result
!= -1 );
539 /****************************************************************************
540 Open the NT printing tdbs. Done once before fork().
541 ****************************************************************************/
543 BOOL
nt_printing_init(void)
545 const char *vstring
= "INFO/version";
549 if ( tdb_drivers
&& tdb_printers
&& tdb_forms
)
553 tdb_close(tdb_drivers
);
554 tdb_drivers
= tdb_open_log(lock_path("ntdrivers.tdb"), 0, TDB_DEFAULT
, O_RDWR
|O_CREAT
, 0600);
556 DEBUG(0,("nt_printing_init: Failed to open nt drivers database %s (%s)\n",
557 lock_path("ntdrivers.tdb"), strerror(errno
) ));
562 tdb_close(tdb_printers
);
563 tdb_printers
= tdb_open_log(lock_path("ntprinters.tdb"), 0, TDB_DEFAULT
, O_RDWR
|O_CREAT
, 0600);
565 DEBUG(0,("nt_printing_init: Failed to open nt printers database %s (%s)\n",
566 lock_path("ntprinters.tdb"), strerror(errno
) ));
571 tdb_close(tdb_forms
);
572 tdb_forms
= tdb_open_log(lock_path("ntforms.tdb"), 0, TDB_DEFAULT
, O_RDWR
|O_CREAT
, 0600);
574 DEBUG(0,("nt_printing_init: Failed to open nt forms database %s (%s)\n",
575 lock_path("ntforms.tdb"), strerror(errno
) ));
579 /* handle a Samba upgrade */
581 vers_id
= tdb_fetch_int32(tdb_drivers
, vstring
);
583 DEBUG(10, ("Fresh database\n"));
584 tdb_store_int32( tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_5
);
585 vers_id
= NTDRIVERS_DATABASE_VERSION_5
;
588 if ( vers_id
!= NTDRIVERS_DATABASE_VERSION_5
) {
590 if ((vers_id
== NTDRIVERS_DATABASE_VERSION_1
) || (IREV(vers_id
) == NTDRIVERS_DATABASE_VERSION_1
)) {
591 if (!upgrade_to_version_3())
593 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_3
);
594 vers_id
= NTDRIVERS_DATABASE_VERSION_3
;
597 if ((vers_id
== NTDRIVERS_DATABASE_VERSION_2
) || (IREV(vers_id
) == NTDRIVERS_DATABASE_VERSION_2
)) {
598 /* Written on a bigendian machine with old fetch_int code. Save as le. */
599 /* The only upgrade between V2 and V3 is to save the version in little-endian. */
600 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_3
);
601 vers_id
= NTDRIVERS_DATABASE_VERSION_3
;
604 if (vers_id
== NTDRIVERS_DATABASE_VERSION_3
) {
605 if ( !upgrade_to_version_4() )
607 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_4
);
608 vers_id
= NTDRIVERS_DATABASE_VERSION_4
;
611 if (vers_id
== NTDRIVERS_DATABASE_VERSION_4
) {
612 if ( !upgrade_to_version_5() )
614 tdb_store_int32(tdb_drivers
, vstring
, NTDRIVERS_DATABASE_VERSION_5
);
615 vers_id
= NTDRIVERS_DATABASE_VERSION_5
;
619 if ( vers_id
!= NTDRIVERS_DATABASE_VERSION_5
) {
620 DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id
));
625 update_c_setprinter(True
);
628 * register callback to handle updating printers as new
629 * drivers are installed
632 message_register(MSG_PRINTER_DRVUPGRADE
, do_drv_upgrade_printer
, NULL
);
635 * register callback to handle updating printer data
636 * when a driver is initialized
639 message_register(MSG_PRINTERDATA_INIT_RESET
, reset_all_printerdata
,
642 /* of course, none of the message callbacks matter if you don't
643 tell messages.c that you interested in receiving PRINT_GENERAL
644 msgs. This is done in claim_connection() */
647 if ( lp_security() == SEC_ADS
) {
648 win_rc
= check_published_printers();
649 if (!W_ERROR_IS_OK(win_rc
))
650 DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", dos_errstr(win_rc
)));
656 /*******************************************************************
657 Function to allow filename parsing "the old way".
658 ********************************************************************/
660 static void driver_unix_convert(char *name
,connection_struct
*conn
,
661 char *saved_last_component
, SMB_STRUCT_STAT
*pst
)
664 unix_clean_name(name
);
665 trim_string(name
,"/","/");
666 unix_convert(conn
, name
, False
, saved_last_component
, pst
);
669 /*******************************************************************
670 tdb traversal function for counting printers.
671 ********************************************************************/
673 static int traverse_counting_printers(TDB_CONTEXT
*t
, TDB_DATA key
,
674 TDB_DATA data
, void *context
)
676 int *printer_count
= (int*)context
;
678 if (memcmp(PRINTERS_PREFIX
, key
.dptr
, sizeof(PRINTERS_PREFIX
)-1) == 0) {
680 DEBUG(10,("traverse_counting_printers: printer = [%s] printer_count = %d\n", key
.dptr
, *printer_count
));
686 /*******************************************************************
687 Update the spooler global c_setprinter. This variable is initialized
688 when the parent smbd starts with the number of existing printers. It
689 is monotonically increased by the current number of printers *after*
690 each add or delete printer RPC. Only Microsoft knows why... JRR020119
691 ********************************************************************/
693 uint32
update_c_setprinter(BOOL initialize
)
696 int32 printer_count
= 0;
698 tdb_lock_bystring(tdb_printers
, GLOBAL_C_SETPRINTER
);
700 /* Traverse the tdb, counting the printers */
701 tdb_traverse(tdb_printers
, traverse_counting_printers
, (void *)&printer_count
);
703 /* If initializing, set c_setprinter to current printers count
704 * otherwise, bump it by the current printer count
707 c_setprinter
= tdb_fetch_int32(tdb_printers
, GLOBAL_C_SETPRINTER
) + printer_count
;
709 c_setprinter
= printer_count
;
711 DEBUG(10,("update_c_setprinter: c_setprinter = %u\n", (unsigned int)c_setprinter
));
712 tdb_store_int32(tdb_printers
, GLOBAL_C_SETPRINTER
, c_setprinter
);
714 tdb_unlock_bystring(tdb_printers
, GLOBAL_C_SETPRINTER
);
716 return (uint32
)c_setprinter
;
719 /*******************************************************************
720 Get the spooler global c_setprinter, accounting for initialization.
721 ********************************************************************/
723 uint32
get_c_setprinter(void)
725 int32 c_setprinter
= tdb_fetch_int32(tdb_printers
, GLOBAL_C_SETPRINTER
);
727 if (c_setprinter
== (int32
)-1)
728 c_setprinter
= update_c_setprinter(True
);
730 DEBUG(10,("get_c_setprinter: c_setprinter = %d\n", c_setprinter
));
732 return (uint32
)c_setprinter
;
735 /****************************************************************************
736 Get builtin form struct list.
737 ****************************************************************************/
739 int get_builtin_ntforms(nt_forms_struct
**list
)
741 *list
= (nt_forms_struct
*)memdup(&default_forms
[0], sizeof(default_forms
));
745 return sizeof(default_forms
) / sizeof(default_forms
[0]);
748 /****************************************************************************
749 get a builtin form struct
750 ****************************************************************************/
752 BOOL
get_a_builtin_ntform(UNISTR2
*uni_formname
,nt_forms_struct
*form
)
756 unistr2_to_ascii(form_name
, uni_formname
, sizeof(form_name
)-1);
757 DEBUGADD(6,("Looking for builtin form %s \n", form_name
));
758 count
= sizeof(default_forms
) / sizeof(default_forms
[0]);
759 for (i
=0;i
<count
;i
++) {
760 if (strequal(form_name
,default_forms
[i
].name
)) {
761 DEBUGADD(6,("Found builtin form %s \n", form_name
));
762 memcpy(form
,&default_forms
[i
],sizeof(*form
));
770 /****************************************************************************
771 get a form struct list.
772 ****************************************************************************/
774 int get_ntforms(nt_forms_struct
**list
)
776 TDB_DATA kbuf
, newkey
, dbuf
;
777 nt_forms_struct form
;
784 for (kbuf
= tdb_firstkey(tdb_forms
);
786 newkey
= tdb_nextkey(tdb_forms
, kbuf
), safe_free(kbuf
.dptr
), kbuf
=newkey
)
788 if (strncmp(kbuf
.dptr
, FORMS_PREFIX
, strlen(FORMS_PREFIX
)) != 0)
791 dbuf
= tdb_fetch(tdb_forms
, kbuf
);
795 fstrcpy(form
.name
, kbuf
.dptr
+strlen(FORMS_PREFIX
));
796 ret
= tdb_unpack(dbuf
.dptr
, dbuf
.dsize
, "dddddddd",
797 &i
, &form
.flag
, &form
.width
, &form
.length
, &form
.left
,
798 &form
.top
, &form
.right
, &form
.bottom
);
799 SAFE_FREE(dbuf
.dptr
);
800 if (ret
!= dbuf
.dsize
)
803 *list
= SMB_REALLOC_ARRAY(*list
, nt_forms_struct
, n
+1);
805 DEBUG(0,("get_ntforms: Realloc fail.\n"));
816 /****************************************************************************
817 write a form struct list
818 ****************************************************************************/
819 int write_ntforms(nt_forms_struct
**list
, int number
)
826 for (i
=0;i
<number
;i
++) {
827 /* save index, so list is rebuilt in correct order */
828 len
= tdb_pack(buf
, sizeof(buf
), "dddddddd",
829 i
, (*list
)[i
].flag
, (*list
)[i
].width
, (*list
)[i
].length
,
830 (*list
)[i
].left
, (*list
)[i
].top
, (*list
)[i
].right
,
832 if (len
> sizeof(buf
)) break;
833 slprintf(key
, sizeof(key
)-1, "%s%s", FORMS_PREFIX
, (*list
)[i
].name
);
834 kbuf
.dsize
= strlen(key
)+1;
838 if (tdb_store(tdb_forms
, kbuf
, dbuf
, TDB_REPLACE
) != 0) break;
844 /****************************************************************************
845 add a form struct at the end of the list
846 ****************************************************************************/
847 BOOL
add_a_form(nt_forms_struct
**list
, const FORM
*form
, int *count
)
854 * NT tries to add forms even when
855 * they are already in the base
856 * only update the values if already present
861 unistr2_to_ascii(form_name
, &form
->name
, sizeof(form_name
)-1);
862 for (n
=0; n
<*count
; n
++) {
863 if ( strequal((*list
)[n
].name
, form_name
) ) {
870 if((*list
=SMB_REALLOC_ARRAY(*list
, nt_forms_struct
, n
+1)) == NULL
) {
871 DEBUG(0,("add_a_form: failed to enlarge forms list!\n"));
874 unistr2_to_ascii((*list
)[n
].name
, &form
->name
, sizeof((*list
)[n
].name
)-1);
878 (*list
)[n
].flag
=form
->flags
;
879 (*list
)[n
].width
=form
->size_x
;
880 (*list
)[n
].length
=form
->size_y
;
881 (*list
)[n
].left
=form
->left
;
882 (*list
)[n
].top
=form
->top
;
883 (*list
)[n
].right
=form
->right
;
884 (*list
)[n
].bottom
=form
->bottom
;
886 DEBUG(6,("add_a_form: Successfully %s form [%s]\n",
887 update
? "updated" : "added", form_name
));
892 /****************************************************************************
893 Delete a named form struct.
894 ****************************************************************************/
896 BOOL
delete_a_form(nt_forms_struct
**list
, UNISTR2
*del_name
, int *count
, WERROR
*ret
)
905 unistr2_to_ascii(form_name
, del_name
, sizeof(form_name
)-1);
907 for (n
=0; n
<*count
; n
++) {
908 if (!strncmp((*list
)[n
].name
, form_name
, strlen(form_name
))) {
909 DEBUG(103, ("delete_a_form, [%s] in list\n", form_name
));
915 DEBUG(10,("delete_a_form, [%s] not found\n", form_name
));
916 *ret
= WERR_INVALID_PARAM
;
920 slprintf(key
, sizeof(key
)-1, "%s%s", FORMS_PREFIX
, (*list
)[n
].name
);
921 kbuf
.dsize
= strlen(key
)+1;
923 if (tdb_delete(tdb_forms
, kbuf
) != 0) {
931 /****************************************************************************
932 Update a form struct.
933 ****************************************************************************/
935 void update_a_form(nt_forms_struct
**list
, const FORM
*form
, int count
)
939 unistr2_to_ascii(form_name
, &(form
->name
), sizeof(form_name
)-1);
941 DEBUG(106, ("[%s]\n", form_name
));
942 for (n
=0; n
<count
; n
++) {
943 DEBUGADD(106, ("n [%d]:[%s]\n", n
, (*list
)[n
].name
));
944 if (!strncmp((*list
)[n
].name
, form_name
, strlen(form_name
)))
948 if (n
==count
) return;
950 (*list
)[n
].flag
=form
->flags
;
951 (*list
)[n
].width
=form
->size_x
;
952 (*list
)[n
].length
=form
->size_y
;
953 (*list
)[n
].left
=form
->left
;
954 (*list
)[n
].top
=form
->top
;
955 (*list
)[n
].right
=form
->right
;
956 (*list
)[n
].bottom
=form
->bottom
;
959 /****************************************************************************
960 Get the nt drivers list.
961 Traverse the database and look-up the matching names.
962 ****************************************************************************/
963 int get_ntdrivers(fstring
**list
, const char *architecture
, uint32 version
)
966 const char *short_archi
;
968 TDB_DATA kbuf
, newkey
;
970 short_archi
= get_short_archi(architecture
);
975 slprintf(key
, sizeof(key
)-1, "%s%s/%d/", DRIVERS_PREFIX
, short_archi
, version
);
977 for (kbuf
= tdb_firstkey(tdb_drivers
);
979 newkey
= tdb_nextkey(tdb_drivers
, kbuf
), safe_free(kbuf
.dptr
), kbuf
=newkey
) {
981 if (strncmp(kbuf
.dptr
, key
, strlen(key
)) != 0)
984 if((*list
= SMB_REALLOC_ARRAY(*list
, fstring
, total
+1)) == NULL
) {
985 DEBUG(0,("get_ntdrivers: failed to enlarge list!\n"));
989 fstrcpy((*list
)[total
], kbuf
.dptr
+strlen(key
));
996 /****************************************************************************
997 Function to do the mapping between the long architecture name and
999 ****************************************************************************/
1001 const char *get_short_archi(const char *long_archi
)
1005 DEBUG(107,("Getting architecture dependant directory\n"));
1008 } while ( (archi_table
[i
].long_archi
!=NULL
) &&
1009 StrCaseCmp(long_archi
, archi_table
[i
].long_archi
) );
1011 if (archi_table
[i
].long_archi
==NULL
) {
1012 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi
));
1016 /* this might be client code - but shouldn't this be an fstrcpy etc? */
1018 DEBUGADD(108,("index: [%d]\n", i
));
1019 DEBUGADD(108,("long architecture: [%s]\n", archi_table
[i
].long_archi
));
1020 DEBUGADD(108,("short architecture: [%s]\n", archi_table
[i
].short_archi
));
1022 return archi_table
[i
].short_archi
;
1025 /****************************************************************************
1026 Version information in Microsoft files is held in a VS_VERSION_INFO structure.
1027 There are two case to be covered here: PE (Portable Executable) and NE (New
1028 Executable) files. Both files support the same INFO structure, but PE files
1029 store the signature in unicode, and NE files store it as !unicode.
1030 returns -1 on error, 1 on version info found, and 0 on no version info found.
1031 ****************************************************************************/
1033 static int get_file_version(files_struct
*fsp
, char *fname
,uint32
*major
, uint32
*minor
)
1039 if ((buf
=(char *)SMB_MALLOC(DOS_HEADER_SIZE
)) == NULL
) {
1040 DEBUG(0,("get_file_version: PE file [%s] DOS Header malloc failed bytes = %d\n",
1041 fname
, DOS_HEADER_SIZE
));
1045 if ((byte_count
= vfs_read_data(fsp
, buf
, DOS_HEADER_SIZE
)) < DOS_HEADER_SIZE
) {
1046 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %lu\n",
1047 fname
, (unsigned long)byte_count
));
1048 goto no_version_info
;
1051 /* Is this really a DOS header? */
1052 if (SVAL(buf
,DOS_HEADER_MAGIC_OFFSET
) != DOS_HEADER_MAGIC
) {
1053 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
1054 fname
, SVAL(buf
,DOS_HEADER_MAGIC_OFFSET
)));
1055 goto no_version_info
;
1058 /* Skip OEM header (if any) and the DOS stub to start of Windows header */
1059 if (SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
, SVAL(buf
,DOS_HEADER_LFANEW_OFFSET
), SEEK_SET
) == (SMB_OFF_T
)-1) {
1060 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
1062 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1063 goto no_version_info
;
1066 /* Note: DOS_HEADER_SIZE and NE_HEADER_SIZE are incidentally same */
1067 if ((byte_count
= vfs_read_data(fsp
, buf
, NE_HEADER_SIZE
)) < NE_HEADER_SIZE
) {
1068 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %lu\n",
1069 fname
, (unsigned long)byte_count
));
1070 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1071 goto no_version_info
;
1074 /* The header may be a PE (Portable Executable) or an NE (New Executable) */
1075 if (IVAL(buf
,PE_HEADER_SIGNATURE_OFFSET
) == PE_HEADER_SIGNATURE
) {
1076 unsigned int num_sections
;
1077 unsigned int section_table_bytes
;
1079 /* Just skip over optional header to get to section table */
1080 if (SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
,
1081 SVAL(buf
,PE_HEADER_OPTIONAL_HEADER_SIZE
)-(NE_HEADER_SIZE
-PE_HEADER_SIZE
),
1082 SEEK_CUR
) == (SMB_OFF_T
)-1) {
1083 DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
1088 /* get the section table */
1089 num_sections
= SVAL(buf
,PE_HEADER_NUMBER_OF_SECTIONS
);
1090 section_table_bytes
= num_sections
* PE_HEADER_SECT_HEADER_SIZE
;
1091 if (section_table_bytes
== 0)
1095 if ((buf
=(char *)SMB_MALLOC(section_table_bytes
)) == NULL
) {
1096 DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
1097 fname
, section_table_bytes
));
1101 if ((byte_count
= vfs_read_data(fsp
, buf
, section_table_bytes
)) < section_table_bytes
) {
1102 DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %lu\n",
1103 fname
, (unsigned long)byte_count
));
1107 /* Iterate the section table looking for the resource section ".rsrc" */
1108 for (i
= 0; i
< num_sections
; i
++) {
1109 int sec_offset
= i
* PE_HEADER_SECT_HEADER_SIZE
;
1111 if (strcmp(".rsrc", &buf
[sec_offset
+PE_HEADER_SECT_NAME_OFFSET
]) == 0) {
1112 unsigned int section_pos
= IVAL(buf
,sec_offset
+PE_HEADER_SECT_PTR_DATA_OFFSET
);
1113 unsigned int section_bytes
= IVAL(buf
,sec_offset
+PE_HEADER_SECT_SIZE_DATA_OFFSET
);
1115 if (section_bytes
== 0)
1119 if ((buf
=(char *)SMB_MALLOC(section_bytes
)) == NULL
) {
1120 DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
1121 fname
, section_bytes
));
1125 /* Seek to the start of the .rsrc section info */
1126 if (SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
, section_pos
, SEEK_SET
) == (SMB_OFF_T
)-1) {
1127 DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
1132 if ((byte_count
= vfs_read_data(fsp
, buf
, section_bytes
)) < section_bytes
) {
1133 DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %lu\n",
1134 fname
, (unsigned long)byte_count
));
1138 if (section_bytes
< VS_VERSION_INFO_UNICODE_SIZE
)
1141 for (i
=0; i
<section_bytes
-VS_VERSION_INFO_UNICODE_SIZE
; i
++) {
1142 /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
1143 if (buf
[i
] == 'V' && buf
[i
+1] == '\0' && buf
[i
+2] == 'S') {
1144 /* Align to next long address */
1145 int pos
= (i
+ sizeof(VS_SIGNATURE
)*2 + 3) & 0xfffffffc;
1147 if (IVAL(buf
,pos
) == VS_MAGIC_VALUE
) {
1148 *major
= IVAL(buf
,pos
+VS_MAJOR_OFFSET
);
1149 *minor
= IVAL(buf
,pos
+VS_MINOR_OFFSET
);
1151 DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1152 fname
, *major
, *minor
,
1153 (*major
>>16)&0xffff, *major
&0xffff,
1154 (*minor
>>16)&0xffff, *minor
&0xffff));
1163 /* Version info not found, fall back to origin date/time */
1164 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname
));
1168 } else if (SVAL(buf
,NE_HEADER_SIGNATURE_OFFSET
) == NE_HEADER_SIGNATURE
) {
1169 if (CVAL(buf
,NE_HEADER_TARGET_OS_OFFSET
) != NE_HEADER_TARGOS_WIN
) {
1170 DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
1171 fname
, CVAL(buf
,NE_HEADER_TARGET_OS_OFFSET
)));
1172 /* At this point, we assume the file is in error. It still could be somthing
1173 * else besides a NE file, but it unlikely at this point. */
1177 /* Allocate a bit more space to speed up things */
1179 if ((buf
=(char *)SMB_MALLOC(VS_NE_BUF_SIZE
)) == NULL
) {
1180 DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes = %d\n",
1181 fname
, PE_HEADER_SIZE
));
1185 /* This is a HACK! I got tired of trying to sort through the messy
1186 * 'NE' file format. If anyone wants to clean this up please have at
1187 * it, but this works. 'NE' files will eventually fade away. JRR */
1188 while((byte_count
= vfs_read_data(fsp
, buf
, VS_NE_BUF_SIZE
)) > 0) {
1189 /* Cover case that should not occur in a well formed 'NE' .dll file */
1190 if (byte_count
-VS_VERSION_INFO_SIZE
<= 0) break;
1192 for(i
=0; i
<byte_count
; i
++) {
1193 /* Fast skip past data that can't possibly match */
1194 if (buf
[i
] != 'V') continue;
1196 /* Potential match data crosses buf boundry, move it to beginning
1197 * of buf, and fill the buf with as much as it will hold. */
1198 if (i
>byte_count
-VS_VERSION_INFO_SIZE
) {
1201 memcpy(buf
, &buf
[i
], byte_count
-i
);
1202 if ((bc
= vfs_read_data(fsp
, &buf
[byte_count
-i
], VS_NE_BUF_SIZE
-
1203 (byte_count
-i
))) < 0) {
1205 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
1210 byte_count
= bc
+ (byte_count
- i
);
1211 if (byte_count
<VS_VERSION_INFO_SIZE
) break;
1216 /* Check that the full signature string and the magic number that
1217 * follows exist (not a perfect solution, but the chances that this
1218 * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
1219 * twice, as it is simpler to read the code. */
1220 if (strcmp(&buf
[i
], VS_SIGNATURE
) == 0) {
1221 /* Compute skip alignment to next long address */
1222 int skip
= -(SMB_VFS_LSEEK(fsp
, fsp
->fh
->fd
, 0, SEEK_CUR
) - (byte_count
- i
) +
1223 sizeof(VS_SIGNATURE
)) & 3;
1224 if (IVAL(buf
,i
+sizeof(VS_SIGNATURE
)+skip
) != 0xfeef04bd) continue;
1226 *major
= IVAL(buf
,i
+sizeof(VS_SIGNATURE
)+skip
+VS_MAJOR_OFFSET
);
1227 *minor
= IVAL(buf
,i
+sizeof(VS_SIGNATURE
)+skip
+VS_MINOR_OFFSET
);
1228 DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1229 fname
, *major
, *minor
,
1230 (*major
>>16)&0xffff, *major
&0xffff,
1231 (*minor
>>16)&0xffff, *minor
&0xffff));
1238 /* Version info not found, fall back to origin date/time */
1239 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname
));
1244 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1245 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
1246 fname
, IVAL(buf
,PE_HEADER_SIGNATURE_OFFSET
)));
1257 /****************************************************************************
1258 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
1259 share one or more files. During the MS installation process files are checked
1260 to insure that only a newer version of a shared file is installed over an
1261 older version. There are several possibilities for this comparison. If there
1262 is no previous version, the new one is newer (obviously). If either file is
1263 missing the version info structure, compare the creation date (on Unix use
1264 the modification date). Otherwise chose the numerically larger version number.
1265 ****************************************************************************/
1267 static int file_version_is_newer(connection_struct
*conn
, fstring new_file
, fstring old_file
)
1269 BOOL use_version
= True
;
1274 time_t new_create_time
;
1278 time_t old_create_time
;
1280 files_struct
*fsp
= NULL
;
1282 SMB_STRUCT_STAT stat_buf
;
1286 SET_STAT_INVALID(st
);
1287 SET_STAT_INVALID(stat_buf
);
1288 new_create_time
= (time_t)0;
1289 old_create_time
= (time_t)0;
1291 /* Get file version info (if available) for previous file (if it exists) */
1292 pstrcpy(filepath
, old_file
);
1294 driver_unix_convert(filepath
,conn
,NULL
,&stat_buf
);
1296 status
= open_file_ntcreate(conn
, filepath
, &stat_buf
,
1298 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1301 FILE_ATTRIBUTE_NORMAL
,
1305 if (!NT_STATUS_IS_OK(status
)) {
1306 /* Old file not found, so by definition new file is in fact newer */
1307 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
1312 int ret
= get_file_version(fsp
, old_file
, &old_major
, &old_minor
);
1318 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1320 use_version
= False
;
1321 if (SMB_VFS_FSTAT(fsp
, fsp
->fh
->fd
, &st
) == -1) goto error_exit
;
1322 old_create_time
= st
.st_mtime
;
1323 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", old_create_time
));
1326 close_file(fsp
, NORMAL_CLOSE
);
1328 /* Get file version info (if available) for new file */
1329 pstrcpy(filepath
, new_file
);
1330 driver_unix_convert(filepath
,conn
,NULL
,&stat_buf
);
1332 status
= open_file_ntcreate(conn
, filepath
, &stat_buf
,
1334 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1337 FILE_ATTRIBUTE_NORMAL
,
1341 if (!NT_STATUS_IS_OK(status
)) {
1342 /* New file not found, this shouldn't occur if the caller did its job */
1343 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1348 int ret
= get_file_version(fsp
, new_file
, &new_major
, &new_minor
);
1354 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1356 use_version
= False
;
1357 if (SMB_VFS_FSTAT(fsp
, fsp
->fh
->fd
, &st
) == -1) goto error_exit
;
1358 new_create_time
= st
.st_mtime
;
1359 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", new_create_time
));
1362 close_file(fsp
, NORMAL_CLOSE
);
1364 if (use_version
&& (new_major
!= old_major
|| new_minor
!= old_minor
)) {
1365 /* Compare versions and choose the larger version number */
1366 if (new_major
> old_major
||
1367 (new_major
== old_major
&& new_minor
> old_minor
)) {
1369 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file
, new_file
));
1373 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file
));
1378 /* Compare modification time/dates and choose the newest time/date */
1379 if (new_create_time
> old_create_time
) {
1380 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file
, new_file
));
1384 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file
));
1391 close_file(fsp
, NORMAL_CLOSE
);
1395 /****************************************************************************
1396 Determine the correct cVersion associated with an architecture and driver
1397 ****************************************************************************/
1398 static uint32
get_correct_cversion(const char *architecture
, fstring driverpath_in
,
1399 struct current_user
*user
, WERROR
*perr
)
1406 files_struct
*fsp
= NULL
;
1408 connection_struct
*conn
;
1411 SET_STAT_INVALID(st
);
1413 *perr
= WERR_INVALID_PARAM
;
1415 /* If architecture is Windows 95/98/ME, the version is always 0. */
1416 if (strcmp(architecture
, SPL_ARCH_WIN40
) == 0) {
1417 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
1422 /* If architecture is Windows x64, the version is always 3. */
1423 if (strcmp(architecture
, SPL_ARCH_X64
) == 0) {
1424 DEBUG(10,("get_correct_cversion: Driver is x64, cversion = 3\n"));
1430 * Connect to the print$ share under the same account as the user connected
1431 * to the rpc pipe. Note we must still be root to do this.
1434 /* Null password is ok - we are already an authenticated user... */
1435 null_pw
= data_blob(NULL
, 0);
1436 fstrcpy(res_type
, "A:");
1438 conn
= make_connection_with_chdir("print$", null_pw
, res_type
, user
->vuid
, &nt_status
);
1442 DEBUG(0,("get_correct_cversion: Unable to connect\n"));
1443 *perr
= ntstatus_to_werror(nt_status
);
1447 /* We are temporarily becoming the connection user. */
1448 if (!become_user(conn
, user
->vuid
)) {
1449 DEBUG(0,("get_correct_cversion: Can't become user!\n"));
1450 *perr
= WERR_ACCESS_DENIED
;
1454 /* Open the driver file (Portable Executable format) and determine the
1455 * deriver the cversion. */
1456 slprintf(driverpath
, sizeof(driverpath
)-1, "%s/%s", architecture
, driverpath_in
);
1458 driver_unix_convert(driverpath
,conn
,NULL
,&st
);
1460 if ( !vfs_file_exist( conn
, driverpath
, &st
) ) {
1461 *perr
= WERR_BADFILE
;
1465 status
= open_file_ntcreate(conn
, driverpath
, &st
,
1467 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1470 FILE_ATTRIBUTE_NORMAL
,
1474 if (!NT_STATUS_IS_OK(status
)) {
1475 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
1476 driverpath
, errno
));
1477 *perr
= WERR_ACCESS_DENIED
;
1482 int ret
= get_file_version(fsp
, driverpath
, &major
, &minor
);
1483 if (ret
== -1) goto error_exit
;
1486 DEBUG(6,("get_correct_cversion: Version info not found [%s]\n", driverpath
));
1491 * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
1492 * for more details. Version in this case is not just the version of the
1493 * file, but the version in the sense of kernal mode (2) vs. user mode
1494 * (3) drivers. Other bits of the version fields are the version info.
1497 cversion
= major
& 0x0000ffff;
1499 case 2: /* WinNT drivers */
1500 case 3: /* Win2K drivers */
1504 DEBUG(6,("get_correct_cversion: cversion invalid [%s] cversion = %d\n",
1505 driverpath
, cversion
));
1509 DEBUG(10,("get_correct_cversion: Version info found [%s] major = 0x%x minor = 0x%x\n",
1510 driverpath
, major
, minor
));
1513 DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
1514 driverpath
, cversion
));
1516 close_file(fsp
, NORMAL_CLOSE
);
1517 close_cnum(conn
, user
->vuid
);
1526 close_file(fsp
, NORMAL_CLOSE
);
1528 close_cnum(conn
, user
->vuid
);
1533 /****************************************************************************
1534 ****************************************************************************/
1535 static WERROR
clean_up_driver_struct_level_3(NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
,
1536 struct current_user
*user
)
1538 const char *architecture
;
1544 /* clean up the driver name.
1545 * we can get .\driver.dll
1546 * or worse c:\windows\system\driver.dll !
1548 /* using an intermediate string to not have overlaping memcpy()'s */
1549 if ((p
= strrchr(driver
->driverpath
,'\\')) != NULL
) {
1550 fstrcpy(new_name
, p
+1);
1551 fstrcpy(driver
->driverpath
, new_name
);
1554 if ((p
= strrchr(driver
->datafile
,'\\')) != NULL
) {
1555 fstrcpy(new_name
, p
+1);
1556 fstrcpy(driver
->datafile
, new_name
);
1559 if ((p
= strrchr(driver
->configfile
,'\\')) != NULL
) {
1560 fstrcpy(new_name
, p
+1);
1561 fstrcpy(driver
->configfile
, new_name
);
1564 if ((p
= strrchr(driver
->helpfile
,'\\')) != NULL
) {
1565 fstrcpy(new_name
, p
+1);
1566 fstrcpy(driver
->helpfile
, new_name
);
1569 if (driver
->dependentfiles
) {
1570 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1571 if ((p
= strrchr(driver
->dependentfiles
[i
],'\\')) != NULL
) {
1572 fstrcpy(new_name
, p
+1);
1573 fstrcpy(driver
->dependentfiles
[i
], new_name
);
1578 architecture
= get_short_archi(driver
->environment
);
1579 if (!architecture
) {
1580 return WERR_UNKNOWN_PRINTER_DRIVER
;
1583 /* jfm:7/16/2000 the client always sends the cversion=0.
1584 * The server should check which version the driver is by reading
1585 * the PE header of driver->driverpath.
1587 * For Windows 95/98 the version is 0 (so the value sent is correct)
1588 * For Windows NT (the architecture doesn't matter)
1589 * NT 3.1: cversion=0
1590 * NT 3.5/3.51: cversion=1
1594 if ((driver
->cversion
= get_correct_cversion( architecture
, driver
->driverpath
, user
, &err
)) == -1)
1600 /****************************************************************************
1601 ****************************************************************************/
1602 static WERROR
clean_up_driver_struct_level_6(NT_PRINTER_DRIVER_INFO_LEVEL_6
*driver
, struct current_user
*user
)
1604 const char *architecture
;
1610 /* clean up the driver name.
1611 * we can get .\driver.dll
1612 * or worse c:\windows\system\driver.dll !
1614 /* using an intermediate string to not have overlaping memcpy()'s */
1615 if ((p
= strrchr(driver
->driverpath
,'\\')) != NULL
) {
1616 fstrcpy(new_name
, p
+1);
1617 fstrcpy(driver
->driverpath
, new_name
);
1620 if ((p
= strrchr(driver
->datafile
,'\\')) != NULL
) {
1621 fstrcpy(new_name
, p
+1);
1622 fstrcpy(driver
->datafile
, new_name
);
1625 if ((p
= strrchr(driver
->configfile
,'\\')) != NULL
) {
1626 fstrcpy(new_name
, p
+1);
1627 fstrcpy(driver
->configfile
, new_name
);
1630 if ((p
= strrchr(driver
->helpfile
,'\\')) != NULL
) {
1631 fstrcpy(new_name
, p
+1);
1632 fstrcpy(driver
->helpfile
, new_name
);
1635 if (driver
->dependentfiles
) {
1636 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1637 if ((p
= strrchr(driver
->dependentfiles
[i
],'\\')) != NULL
) {
1638 fstrcpy(new_name
, p
+1);
1639 fstrcpy(driver
->dependentfiles
[i
], new_name
);
1644 architecture
= get_short_archi(driver
->environment
);
1645 if (!architecture
) {
1646 return WERR_UNKNOWN_PRINTER_DRIVER
;
1649 /* jfm:7/16/2000 the client always sends the cversion=0.
1650 * The server should check which version the driver is by reading
1651 * the PE header of driver->driverpath.
1653 * For Windows 95/98 the version is 0 (so the value sent is correct)
1654 * For Windows NT (the architecture doesn't matter)
1655 * NT 3.1: cversion=0
1656 * NT 3.5/3.51: cversion=1
1661 if ((driver
->version
= get_correct_cversion(architecture
, driver
->driverpath
, user
, &err
)) == -1)
1667 /****************************************************************************
1668 ****************************************************************************/
1669 WERROR
clean_up_driver_struct(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract
,
1670 uint32 level
, struct current_user
*user
)
1675 NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
;
1676 driver
=driver_abstract
.info_3
;
1677 return clean_up_driver_struct_level_3(driver
, user
);
1681 NT_PRINTER_DRIVER_INFO_LEVEL_6
*driver
;
1682 driver
=driver_abstract
.info_6
;
1683 return clean_up_driver_struct_level_6(driver
, user
);
1686 return WERR_INVALID_PARAM
;
1690 /****************************************************************************
1691 This function sucks and should be replaced. JRA.
1692 ****************************************************************************/
1694 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3
*dst
, NT_PRINTER_DRIVER_INFO_LEVEL_6
*src
)
1696 dst
->cversion
= src
->version
;
1698 fstrcpy( dst
->name
, src
->name
);
1699 fstrcpy( dst
->environment
, src
->environment
);
1700 fstrcpy( dst
->driverpath
, src
->driverpath
);
1701 fstrcpy( dst
->datafile
, src
->datafile
);
1702 fstrcpy( dst
->configfile
, src
->configfile
);
1703 fstrcpy( dst
->helpfile
, src
->helpfile
);
1704 fstrcpy( dst
->monitorname
, src
->monitorname
);
1705 fstrcpy( dst
->defaultdatatype
, src
->defaultdatatype
);
1706 dst
->dependentfiles
= src
->dependentfiles
;
1709 #if 0 /* Debugging function */
1711 static char* ffmt(unsigned char *c
){
1713 static char ffmt_str
[17];
1715 for (i
=0; i
<16; i
++) {
1716 if ((c
[i
] < ' ') || (c
[i
] > '~'))
1727 /****************************************************************************
1728 ****************************************************************************/
1729 WERROR
move_driver_to_download_area(NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract
, uint32 level
,
1730 struct current_user
*user
, WERROR
*perr
)
1732 NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
;
1733 NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver
;
1734 const char *architecture
;
1739 connection_struct
*conn
;
1748 memset(inbuf
, '\0', sizeof(inbuf
));
1749 memset(outbuf
, '\0', sizeof(outbuf
));
1753 driver
=driver_abstract
.info_3
;
1754 else if (level
==6) {
1755 convert_level_6_to_level3(&converted_driver
, driver_abstract
.info_6
);
1756 driver
= &converted_driver
;
1758 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level
));
1759 return WERR_UNKNOWN_LEVEL
;
1762 architecture
= get_short_archi(driver
->environment
);
1763 if (!architecture
) {
1764 return WERR_UNKNOWN_PRINTER_DRIVER
;
1768 * Connect to the print$ share under the same account as the user connected to the rpc pipe.
1769 * Note we must be root to do this.
1772 null_pw
= data_blob(NULL
, 0);
1773 fstrcpy(res_type
, "A:");
1775 conn
= make_connection_with_chdir("print$", null_pw
, res_type
, user
->vuid
, &nt_status
);
1779 DEBUG(0,("move_driver_to_download_area: Unable to connect\n"));
1780 *perr
= ntstatus_to_werror(nt_status
);
1781 return WERR_NO_SUCH_SHARE
;
1785 * Save who we are - we are temporarily becoming the connection user.
1788 if (!become_user(conn
, conn
->vuid
)) {
1789 DEBUG(0,("move_driver_to_download_area: Can't become user!\n"));
1790 return WERR_ACCESS_DENIED
;
1794 * make the directories version and version\driver_name
1795 * under the architecture directory.
1797 DEBUG(5,("Creating first directory\n"));
1798 slprintf(new_dir
, sizeof(new_dir
)-1, "%s/%d", architecture
, driver
->cversion
);
1799 driver_unix_convert(new_dir
, conn
, NULL
, &st
);
1800 create_directory(conn
, new_dir
);
1802 /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1803 * listed for this driver which has already been moved, skip it (note:
1804 * drivers may list the same file name several times. Then check if the
1805 * file already exists in archi\cversion\, if so, check that the version
1806 * info (or time stamps if version info is unavailable) is newer (or the
1807 * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1808 * Otherwise, delete the file.
1810 * If a file is not moved to archi\cversion\ because of an error, all the
1811 * rest of the 'unmoved' driver files are removed from archi\. If one or
1812 * more of the driver's files was already moved to archi\cversion\, it
1813 * potentially leaves the driver in a partially updated state. Version
1814 * trauma will most likely occur if an client attempts to use any printer
1815 * bound to the driver. Perhaps a rewrite to make sure the moves can be
1816 * done is appropriate... later JRR
1819 DEBUG(5,("Moving files now !\n"));
1821 if (driver
->driverpath
&& strlen(driver
->driverpath
)) {
1822 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->driverpath
);
1823 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->driverpath
);
1824 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1825 driver_unix_convert(new_name
, conn
, NULL
, &st
);
1826 if ( !NT_STATUS_IS_OK(copy_file(conn
, new_name
, old_name
, OPENX_FILE_EXISTS_TRUNCATE
|
1827 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
))) {
1828 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1829 new_name
, old_name
));
1830 *perr
= WERR_ACCESS_DENIED
;
1836 if (driver
->datafile
&& strlen(driver
->datafile
)) {
1837 if (!strequal(driver
->datafile
, driver
->driverpath
)) {
1838 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->datafile
);
1839 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->datafile
);
1840 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1841 driver_unix_convert(new_name
, conn
, NULL
, &st
);
1842 if ( !NT_STATUS_IS_OK(copy_file(conn
, new_name
, old_name
, OPENX_FILE_EXISTS_TRUNCATE
|
1843 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
))) {
1844 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1845 new_name
, old_name
));
1846 *perr
= WERR_ACCESS_DENIED
;
1853 if (driver
->configfile
&& strlen(driver
->configfile
)) {
1854 if (!strequal(driver
->configfile
, driver
->driverpath
) &&
1855 !strequal(driver
->configfile
, driver
->datafile
)) {
1856 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->configfile
);
1857 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->configfile
);
1858 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1859 driver_unix_convert(new_name
, conn
, NULL
, &st
);
1860 if ( !NT_STATUS_IS_OK(copy_file(conn
, new_name
, old_name
, OPENX_FILE_EXISTS_TRUNCATE
|
1861 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
))) {
1862 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1863 new_name
, old_name
));
1864 *perr
= WERR_ACCESS_DENIED
;
1871 if (driver
->helpfile
&& strlen(driver
->helpfile
)) {
1872 if (!strequal(driver
->helpfile
, driver
->driverpath
) &&
1873 !strequal(driver
->helpfile
, driver
->datafile
) &&
1874 !strequal(driver
->helpfile
, driver
->configfile
)) {
1875 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->helpfile
);
1876 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->helpfile
);
1877 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1878 driver_unix_convert(new_name
, conn
, NULL
, &st
);
1879 if ( !NT_STATUS_IS_OK(copy_file(conn
, new_name
, old_name
, OPENX_FILE_EXISTS_TRUNCATE
|
1880 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
))) {
1881 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1882 new_name
, old_name
));
1883 *perr
= WERR_ACCESS_DENIED
;
1890 if (driver
->dependentfiles
) {
1891 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1892 if (!strequal(driver
->dependentfiles
[i
], driver
->driverpath
) &&
1893 !strequal(driver
->dependentfiles
[i
], driver
->datafile
) &&
1894 !strequal(driver
->dependentfiles
[i
], driver
->configfile
) &&
1895 !strequal(driver
->dependentfiles
[i
], driver
->helpfile
)) {
1897 for (j
=0; j
< i
; j
++) {
1898 if (strequal(driver
->dependentfiles
[i
], driver
->dependentfiles
[j
])) {
1903 slprintf(new_name
, sizeof(new_name
)-1, "%s/%s", architecture
, driver
->dependentfiles
[i
]);
1904 slprintf(old_name
, sizeof(old_name
)-1, "%s/%s", new_dir
, driver
->dependentfiles
[i
]);
1905 if (ver
!= -1 && (ver
=file_version_is_newer(conn
, new_name
, old_name
)) > 0) {
1906 driver_unix_convert(new_name
, conn
, NULL
, &st
);
1907 if ( !NT_STATUS_IS_OK(copy_file(conn
, new_name
, old_name
,
1908 OPENX_FILE_EXISTS_TRUNCATE
|
1909 OPENX_FILE_CREATE_IF_NOT_EXIST
, 0, False
))) {
1910 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1911 new_name
, old_name
));
1912 *perr
= WERR_ACCESS_DENIED
;
1921 close_cnum(conn
, user
->vuid
);
1924 return ver
!= -1 ? WERR_OK
: WERR_UNKNOWN_PRINTER_DRIVER
;
1927 /****************************************************************************
1928 ****************************************************************************/
1929 static uint32
add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3
*driver
)
1932 const char *architecture
;
1938 TDB_DATA kbuf
, dbuf
;
1940 architecture
= get_short_archi(driver
->environment
);
1941 if (!architecture
) {
1945 /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
1946 * \\server is added in the rpc server layer.
1947 * It does make sense to NOT store the server's name in the printer TDB.
1950 slprintf(directory
, sizeof(directory
)-1, "\\print$\\%s\\%d\\", architecture
, driver
->cversion
);
1952 /* .inf files do not always list a file for each of the four standard files.
1953 * Don't prepend a path to a null filename, or client claims:
1954 * "The server on which the printer resides does not have a suitable
1955 * <printer driver name> printer driver installed. Click OK if you
1956 * wish to install the driver on your local machine."
1958 if (strlen(driver
->driverpath
)) {
1959 fstrcpy(temp_name
, driver
->driverpath
);
1960 slprintf(driver
->driverpath
, sizeof(driver
->driverpath
)-1, "%s%s", directory
, temp_name
);
1963 if (strlen(driver
->datafile
)) {
1964 fstrcpy(temp_name
, driver
->datafile
);
1965 slprintf(driver
->datafile
, sizeof(driver
->datafile
)-1, "%s%s", directory
, temp_name
);
1968 if (strlen(driver
->configfile
)) {
1969 fstrcpy(temp_name
, driver
->configfile
);
1970 slprintf(driver
->configfile
, sizeof(driver
->configfile
)-1, "%s%s", directory
, temp_name
);
1973 if (strlen(driver
->helpfile
)) {
1974 fstrcpy(temp_name
, driver
->helpfile
);
1975 slprintf(driver
->helpfile
, sizeof(driver
->helpfile
)-1, "%s%s", directory
, temp_name
);
1978 if (driver
->dependentfiles
) {
1979 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
1980 fstrcpy(temp_name
, driver
->dependentfiles
[i
]);
1981 slprintf(driver
->dependentfiles
[i
], sizeof(driver
->dependentfiles
[i
])-1, "%s%s", directory
, temp_name
);
1985 slprintf(key
, sizeof(key
)-1, "%s%s/%d/%s", DRIVERS_PREFIX
, architecture
, driver
->cversion
, driver
->name
);
1987 DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key
));
1994 len
+= tdb_pack(buf
+len
, buflen
-len
, "dffffffff",
1997 driver
->environment
,
2002 driver
->monitorname
,
2003 driver
->defaultdatatype
);
2005 if (driver
->dependentfiles
) {
2006 for (i
=0; *driver
->dependentfiles
[i
]; i
++) {
2007 len
+= tdb_pack(buf
+len
, buflen
-len
, "f",
2008 driver
->dependentfiles
[i
]);
2012 if (len
!= buflen
) {
2013 buf
= (char *)SMB_REALLOC(buf
, len
);
2015 DEBUG(0,("add_a_printer_driver_3: failed to enlarge buffer\n!"));
2025 kbuf
.dsize
= strlen(key
)+1;
2029 ret
= tdb_store(tdb_drivers
, kbuf
, dbuf
, TDB_REPLACE
);
2033 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key
));
2039 /****************************************************************************
2040 ****************************************************************************/
2041 static uint32
add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6
*driver
)
2043 NT_PRINTER_DRIVER_INFO_LEVEL_3 info3
;
2046 info3
.cversion
= driver
->version
;
2047 fstrcpy(info3
.name
,driver
->name
);
2048 fstrcpy(info3
.environment
,driver
->environment
);
2049 fstrcpy(info3
.driverpath
,driver
->driverpath
);
2050 fstrcpy(info3
.datafile
,driver
->datafile
);
2051 fstrcpy(info3
.configfile
,driver
->configfile
);
2052 fstrcpy(info3
.helpfile
,driver
->helpfile
);
2053 fstrcpy(info3
.monitorname
,driver
->monitorname
);
2054 fstrcpy(info3
.defaultdatatype
,driver
->defaultdatatype
);
2055 info3
.dependentfiles
= driver
->dependentfiles
;
2057 return add_a_printer_driver_3(&info3
);
2061 /****************************************************************************
2062 ****************************************************************************/
2063 static WERROR
get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3
**info_ptr
, const char *driver
, const char *arch
)
2065 NT_PRINTER_DRIVER_INFO_LEVEL_3 info
;
2069 fstrcpy(info
.name
, driver
);
2070 fstrcpy(info
.defaultdatatype
, "RAW");
2072 fstrcpy(info
.driverpath
, "");
2073 fstrcpy(info
.datafile
, "");
2074 fstrcpy(info
.configfile
, "");
2075 fstrcpy(info
.helpfile
, "");
2077 if ((info
.dependentfiles
= SMB_MALLOC_ARRAY(fstring
, 2)) == NULL
)
2080 memset(info
.dependentfiles
, '\0', 2*sizeof(fstring
));
2081 fstrcpy(info
.dependentfiles
[0], "");
2083 *info_ptr
= (NT_PRINTER_DRIVER_INFO_LEVEL_3
*)memdup(&info
, sizeof(info
));
2085 SAFE_FREE(info
.dependentfiles
);
2092 /****************************************************************************
2093 ****************************************************************************/
2094 static WERROR
get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3
**info_ptr
, fstring drivername
, const char *arch
, uint32 version
)
2096 NT_PRINTER_DRIVER_INFO_LEVEL_3 driver
;
2097 TDB_DATA kbuf
, dbuf
;
2098 const char *architecture
;
2103 ZERO_STRUCT(driver
);
2105 architecture
= get_short_archi(arch
);
2106 if ( !architecture
) {
2107 return WERR_UNKNOWN_PRINTER_DRIVER
;
2110 /* Windows 4.0 (i.e. win9x) should always use a version of 0 */
2112 if ( strcmp( architecture
, SPL_ARCH_WIN40
) == 0 )
2115 DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX
, architecture
, version
, drivername
));
2117 slprintf(key
, sizeof(key
)-1, "%s%s/%d/%s", DRIVERS_PREFIX
, architecture
, version
, drivername
);
2120 kbuf
.dsize
= strlen(key
)+1;
2122 dbuf
= tdb_fetch(tdb_drivers
, kbuf
);
2124 return WERR_UNKNOWN_PRINTER_DRIVER
;
2126 len
+= tdb_unpack(dbuf
.dptr
, dbuf
.dsize
, "dffffffff",
2135 driver
.defaultdatatype
);
2138 while (len
< dbuf
.dsize
) {
2139 driver
.dependentfiles
= SMB_REALLOC_ARRAY(driver
.dependentfiles
, fstring
, i
+2);
2140 if ( !driver
.dependentfiles
) {
2141 DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
2145 len
+= tdb_unpack(dbuf
.dptr
+len
, dbuf
.dsize
-len
, "f",
2146 &driver
.dependentfiles
[i
]);
2150 if ( driver
.dependentfiles
)
2151 fstrcpy( driver
.dependentfiles
[i
], "" );
2153 SAFE_FREE(dbuf
.dptr
);
2155 if (len
!= dbuf
.dsize
) {
2156 SAFE_FREE(driver
.dependentfiles
);
2158 return get_a_printer_driver_3_default(info_ptr
, drivername
, arch
);
2161 *info_ptr
= (NT_PRINTER_DRIVER_INFO_LEVEL_3
*)memdup(&driver
, sizeof(driver
));
2163 SAFE_FREE(driver
.dependentfiles
);
2170 /****************************************************************************
2171 Debugging function, dump at level 6 the struct in the logs.
2172 ****************************************************************************/
2174 static uint32
dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver
, uint32 level
)
2177 NT_PRINTER_DRIVER_INFO_LEVEL_3
*info3
;
2180 DEBUG(20,("Dumping printer driver at level [%d]\n", level
));
2186 if (driver
.info_3
== NULL
)
2189 info3
=driver
.info_3
;
2191 DEBUGADD(20,("version:[%d]\n", info3
->cversion
));
2192 DEBUGADD(20,("name:[%s]\n", info3
->name
));
2193 DEBUGADD(20,("environment:[%s]\n", info3
->environment
));
2194 DEBUGADD(20,("driverpath:[%s]\n", info3
->driverpath
));
2195 DEBUGADD(20,("datafile:[%s]\n", info3
->datafile
));
2196 DEBUGADD(20,("configfile:[%s]\n", info3
->configfile
));
2197 DEBUGADD(20,("helpfile:[%s]\n", info3
->helpfile
));
2198 DEBUGADD(20,("monitorname:[%s]\n", info3
->monitorname
));
2199 DEBUGADD(20,("defaultdatatype:[%s]\n", info3
->defaultdatatype
));
2201 for (i
=0; info3
->dependentfiles
&&
2202 *info3
->dependentfiles
[i
]; i
++) {
2203 DEBUGADD(20,("dependentfile:[%s]\n",
2204 info3
->dependentfiles
[i
]));
2211 DEBUGADD(20,("dump_a_printer_driver: Level %u not implemented\n", (unsigned int)level
));
2219 /****************************************************************************
2220 ****************************************************************************/
2221 int pack_devicemode(NT_DEVICEMODE
*nt_devmode
, char *buf
, int buflen
)
2225 len
+= tdb_pack(buf
+len
, buflen
-len
, "p", nt_devmode
);
2230 len
+= tdb_pack(buf
+len
, buflen
-len
, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2231 nt_devmode
->devicename
,
2232 nt_devmode
->formname
,
2234 nt_devmode
->specversion
,
2235 nt_devmode
->driverversion
,
2237 nt_devmode
->driverextra
,
2238 nt_devmode
->orientation
,
2239 nt_devmode
->papersize
,
2240 nt_devmode
->paperlength
,
2241 nt_devmode
->paperwidth
,
2244 nt_devmode
->defaultsource
,
2245 nt_devmode
->printquality
,
2248 nt_devmode
->yresolution
,
2249 nt_devmode
->ttoption
,
2250 nt_devmode
->collate
,
2251 nt_devmode
->logpixels
,
2254 nt_devmode
->bitsperpel
,
2255 nt_devmode
->pelswidth
,
2256 nt_devmode
->pelsheight
,
2257 nt_devmode
->displayflags
,
2258 nt_devmode
->displayfrequency
,
2259 nt_devmode
->icmmethod
,
2260 nt_devmode
->icmintent
,
2261 nt_devmode
->mediatype
,
2262 nt_devmode
->dithertype
,
2263 nt_devmode
->reserved1
,
2264 nt_devmode
->reserved2
,
2265 nt_devmode
->panningwidth
,
2266 nt_devmode
->panningheight
,
2267 nt_devmode
->nt_dev_private
);
2270 if (nt_devmode
->nt_dev_private
) {
2271 len
+= tdb_pack(buf
+len
, buflen
-len
, "B",
2272 nt_devmode
->driverextra
,
2273 nt_devmode
->nt_dev_private
);
2276 DEBUG(8,("Packed devicemode [%s]\n", nt_devmode
->formname
));
2281 /****************************************************************************
2282 Pack all values in all printer keys
2283 ***************************************************************************/
2285 static int pack_values(NT_PRINTER_DATA
*data
, char *buf
, int buflen
)
2289 REGISTRY_VALUE
*val
;
2290 REGVAL_CTR
*val_ctr
;
2297 /* loop over all keys */
2299 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2300 val_ctr
= data
->keys
[i
].values
;
2301 num_values
= regval_ctr_numvals( val_ctr
);
2303 /* pack the keyname followed by a empty value */
2305 len
+= tdb_pack(buf
+len
, buflen
-len
, "pPdB",
2306 &data
->keys
[i
].name
,
2312 /* now loop over all values */
2314 for ( j
=0; j
<num_values
; j
++ ) {
2315 /* pathname should be stored as <key>\<value> */
2317 val
= regval_ctr_specific_value( val_ctr
, j
);
2318 pstrcpy( path
, data
->keys
[i
].name
);
2319 pstrcat( path
, "\\" );
2320 pstrcat( path
, regval_name(val
) );
2322 len
+= tdb_pack(buf
+len
, buflen
-len
, "pPdB",
2327 regval_data_p(val
) );
2329 DEBUG(8,("specific: [%s], len: %d\n", regval_name(val
), regval_size(val
)));
2336 len
+= tdb_pack(buf
+len
, buflen
-len
, "p", NULL
);
2342 /****************************************************************************
2343 Delete a printer - this just deletes the printer info file, any open
2344 handles are not affected.
2345 ****************************************************************************/
2347 uint32
del_a_printer(const char *sharename
)
2350 pstring printdb_path
;
2352 kbuf
= make_printer_tdbkey( sharename
);
2353 tdb_delete(tdb_printers
, kbuf
);
2355 kbuf
.dptr
= make_printers_secdesc_tdbkey( sharename
);
2356 kbuf
.dsize
= strlen(kbuf
.dptr
) + 1;
2357 tdb_delete(tdb_printers
, kbuf
);
2359 close_all_print_db();
2361 if (geteuid() == 0) {
2362 pstrcpy(printdb_path
, lock_path("printing/"));
2363 pstrcat(printdb_path
, sharename
);
2364 pstrcat(printdb_path
, ".tdb");
2366 unlink(printdb_path
);
2372 /****************************************************************************
2373 ****************************************************************************/
2374 static WERROR
update_a_printer_2(NT_PRINTER_INFO_LEVEL_2
*info
)
2379 TDB_DATA kbuf
, dbuf
;
2382 * in addprinter: no servername and the printer is the name
2383 * in setprinter: servername is \\server
2384 * and printer is \\server\\printer
2386 * Samba manages only local printers.
2387 * we currently don't support things like i
2388 * path=\\other_server\printer
2390 * We only store the printername, not \\server\printername
2393 if ( info
->servername
[0] != '\0' ) {
2394 trim_string(info
->printername
, info
->servername
, NULL
);
2395 trim_char(info
->printername
, '\\', '\0');
2396 info
->servername
[0]='\0';
2400 * JFM: one day I'll forget.
2401 * below that's info->portname because that's the SAMBA sharename
2402 * and I made NT 'thinks' it's the portname
2403 * the info->sharename is the thing you can name when you add a printer
2404 * that's the short-name when you create shared printer for 95/98
2405 * So I've made a limitation in SAMBA: you can only have 1 printer model
2406 * behind a SAMBA share.
2414 len
+= tdb_pack(buf
+len
, buflen
-len
, "dddddddddddfffffPfffff",
2417 info
->default_priority
,
2434 info
->printprocessor
,
2438 len
+= pack_devicemode(info
->devmode
, buf
+len
, buflen
-len
);
2440 len
+= pack_values( info
->data
, buf
+len
, buflen
-len
);
2442 if (buflen
!= len
) {
2443 buf
= (char *)SMB_REALLOC(buf
, len
);
2445 DEBUG(0,("update_a_printer_2: failed to enlarge buffer!\n"));
2454 kbuf
= make_printer_tdbkey( info
->sharename
);
2459 ret
= (tdb_store(tdb_printers
, kbuf
, dbuf
, TDB_REPLACE
) == 0? WERR_OK
: WERR_NOMEM
);
2462 if (!W_ERROR_IS_OK(ret
))
2463 DEBUG(8, ("error updating printer to tdb on disk\n"));
2467 DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
2468 info
->sharename
, info
->drivername
, info
->portname
, len
));
2474 /****************************************************************************
2475 Malloc and return an NT devicemode.
2476 ****************************************************************************/
2478 NT_DEVICEMODE
*construct_nt_devicemode(const fstring default_devicename
)
2481 char adevice
[MAXDEVICENAME
];
2482 NT_DEVICEMODE
*nt_devmode
= SMB_MALLOC_P(NT_DEVICEMODE
);
2484 if (nt_devmode
== NULL
) {
2485 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
2489 ZERO_STRUCTP(nt_devmode
);
2491 slprintf(adevice
, sizeof(adevice
), "%s", default_devicename
);
2492 fstrcpy(nt_devmode
->devicename
, adevice
);
2494 fstrcpy(nt_devmode
->formname
, "Letter");
2496 nt_devmode
->specversion
= 0x0401;
2497 nt_devmode
->driverversion
= 0x0400;
2498 nt_devmode
->size
= 0x00DC;
2499 nt_devmode
->driverextra
= 0x0000;
2500 nt_devmode
->fields
= FORMNAME
| TTOPTION
| PRINTQUALITY
|
2501 DEFAULTSOURCE
| COPIES
| SCALE
|
2502 PAPERSIZE
| ORIENTATION
;
2503 nt_devmode
->orientation
= 1;
2504 nt_devmode
->papersize
= PAPER_LETTER
;
2505 nt_devmode
->paperlength
= 0;
2506 nt_devmode
->paperwidth
= 0;
2507 nt_devmode
->scale
= 0x64;
2508 nt_devmode
->copies
= 1;
2509 nt_devmode
->defaultsource
= BIN_FORMSOURCE
;
2510 nt_devmode
->printquality
= RES_HIGH
; /* 0x0258 */
2511 nt_devmode
->color
= COLOR_MONOCHROME
;
2512 nt_devmode
->duplex
= DUP_SIMPLEX
;
2513 nt_devmode
->yresolution
= 0;
2514 nt_devmode
->ttoption
= TT_SUBDEV
;
2515 nt_devmode
->collate
= COLLATE_FALSE
;
2516 nt_devmode
->icmmethod
= 0;
2517 nt_devmode
->icmintent
= 0;
2518 nt_devmode
->mediatype
= 0;
2519 nt_devmode
->dithertype
= 0;
2521 /* non utilisés par un driver d'imprimante */
2522 nt_devmode
->logpixels
= 0;
2523 nt_devmode
->bitsperpel
= 0;
2524 nt_devmode
->pelswidth
= 0;
2525 nt_devmode
->pelsheight
= 0;
2526 nt_devmode
->displayflags
= 0;
2527 nt_devmode
->displayfrequency
= 0;
2528 nt_devmode
->reserved1
= 0;
2529 nt_devmode
->reserved2
= 0;
2530 nt_devmode
->panningwidth
= 0;
2531 nt_devmode
->panningheight
= 0;
2533 nt_devmode
->nt_dev_private
= NULL
;
2537 /****************************************************************************
2538 Deepcopy an NT devicemode.
2539 ****************************************************************************/
2541 NT_DEVICEMODE
*dup_nt_devicemode(NT_DEVICEMODE
*nt_devicemode
)
2543 NT_DEVICEMODE
*new_nt_devicemode
= NULL
;
2545 if ( !nt_devicemode
)
2548 if ((new_nt_devicemode
= (NT_DEVICEMODE
*)memdup(nt_devicemode
, sizeof(NT_DEVICEMODE
))) == NULL
) {
2549 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2553 new_nt_devicemode
->nt_dev_private
= NULL
;
2554 if (nt_devicemode
->nt_dev_private
!= NULL
) {
2555 if ((new_nt_devicemode
->nt_dev_private
= (uint8
*)memdup(nt_devicemode
->nt_dev_private
, nt_devicemode
->driverextra
)) == NULL
) {
2556 SAFE_FREE(new_nt_devicemode
);
2557 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2562 return new_nt_devicemode
;
2565 /****************************************************************************
2566 Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
2567 ****************************************************************************/
2569 void free_nt_devicemode(NT_DEVICEMODE
**devmode_ptr
)
2571 NT_DEVICEMODE
*nt_devmode
= *devmode_ptr
;
2573 if(nt_devmode
== NULL
)
2576 DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
2578 SAFE_FREE(nt_devmode
->nt_dev_private
);
2579 SAFE_FREE(*devmode_ptr
);
2582 /****************************************************************************
2583 Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
2584 ****************************************************************************/
2586 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2
**info_ptr
)
2588 NT_PRINTER_INFO_LEVEL_2
*info
= *info_ptr
;
2593 free_nt_devicemode(&info
->devmode
);
2595 TALLOC_FREE( *info_ptr
);
2599 /****************************************************************************
2600 ****************************************************************************/
2601 int unpack_devicemode(NT_DEVICEMODE
**nt_devmode
, char *buf
, int buflen
)
2605 NT_DEVICEMODE devmode
;
2607 ZERO_STRUCT(devmode
);
2609 len
+= tdb_unpack(buf
+len
, buflen
-len
, "p", nt_devmode
);
2611 if (!*nt_devmode
) return len
;
2613 len
+= tdb_unpack(buf
+len
, buflen
-len
, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2617 &devmode
.specversion
,
2618 &devmode
.driverversion
,
2620 &devmode
.driverextra
,
2621 &devmode
.orientation
,
2623 &devmode
.paperlength
,
2624 &devmode
.paperwidth
,
2627 &devmode
.defaultsource
,
2628 &devmode
.printquality
,
2631 &devmode
.yresolution
,
2637 &devmode
.bitsperpel
,
2639 &devmode
.pelsheight
,
2640 &devmode
.displayflags
,
2641 &devmode
.displayfrequency
,
2645 &devmode
.dithertype
,
2648 &devmode
.panningwidth
,
2649 &devmode
.panningheight
,
2650 &devmode
.nt_dev_private
);
2652 if (devmode
.nt_dev_private
) {
2653 /* the len in tdb_unpack is an int value and
2654 * devmode.driverextra is only a short
2656 len
+= tdb_unpack(buf
+len
, buflen
-len
, "B", &extra_len
, &devmode
.nt_dev_private
);
2657 devmode
.driverextra
=(uint16
)extra_len
;
2659 /* check to catch an invalid TDB entry so we don't segfault */
2660 if (devmode
.driverextra
== 0) {
2661 devmode
.nt_dev_private
= NULL
;
2665 *nt_devmode
= (NT_DEVICEMODE
*)memdup(&devmode
, sizeof(devmode
));
2667 SAFE_FREE(devmode
.nt_dev_private
);
2671 DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode
.devicename
, devmode
.formname
));
2672 if (devmode
.nt_dev_private
)
2673 DEBUG(8,("with a private section of %d bytes\n", devmode
.driverextra
));
2678 /****************************************************************************
2679 Allocate and initialize a new slot.
2680 ***************************************************************************/
2682 int add_new_printer_key( NT_PRINTER_DATA
*data
, const char *name
)
2687 if ( !name
|| !data
)
2690 /* allocate another slot in the NT_PRINTER_KEY array */
2692 if ( !(d
= TALLOC_REALLOC_ARRAY( data
, data
->keys
, NT_PRINTER_KEY
, data
->num_keys
+1)) ) {
2693 DEBUG(0,("add_new_printer_key: Realloc() failed!\n"));
2699 key_index
= data
->num_keys
;
2701 /* initialze new key */
2703 data
->keys
[key_index
].name
= talloc_strdup( data
, name
);
2705 if ( !(data
->keys
[key_index
].values
= TALLOC_ZERO_P( data
, REGVAL_CTR
)) )
2710 DEBUG(10,("add_new_printer_key: Inserted new data key [%s]\n", name
));
2715 /****************************************************************************
2716 search for a registry key name in the existing printer data
2717 ***************************************************************************/
2719 int delete_printer_key( NT_PRINTER_DATA
*data
, const char *name
)
2723 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2724 if ( strequal( data
->keys
[i
].name
, name
) ) {
2726 /* cleanup memory */
2728 TALLOC_FREE( data
->keys
[i
].name
);
2729 TALLOC_FREE( data
->keys
[i
].values
);
2731 /* if not the end of the array, move remaining elements down one slot */
2734 if ( data
->num_keys
&& (i
< data
->num_keys
) )
2735 memmove( &data
->keys
[i
], &data
->keys
[i
+1], sizeof(NT_PRINTER_KEY
)*(data
->num_keys
-i
) );
2742 return data
->num_keys
;
2745 /****************************************************************************
2746 search for a registry key name in the existing printer data
2747 ***************************************************************************/
2749 int lookup_printerkey( NT_PRINTER_DATA
*data
, const char *name
)
2754 if ( !data
|| !name
)
2757 DEBUG(12,("lookup_printerkey: Looking for [%s]\n", name
));
2759 /* loop over all existing keys */
2761 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2762 if ( strequal(data
->keys
[i
].name
, name
) ) {
2763 DEBUG(12,("lookup_printerkey: Found [%s]!\n", name
));
2773 /****************************************************************************
2774 ***************************************************************************/
2776 int get_printer_subkeys( NT_PRINTER_DATA
*data
, const char* key
, fstring
**subkeys
)
2780 int num_subkeys
= 0;
2782 fstring
*subkeys_ptr
= NULL
;
2793 /* special case of asking for the top level printer data registry key names */
2795 if ( strlen(key
) == 0 ) {
2796 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2798 /* found a match, so allocate space and copy the name */
2800 if ( !(subkeys_ptr
= SMB_REALLOC_ARRAY( subkeys_ptr
, fstring
, num_subkeys
+2)) ) {
2801 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
2806 fstrcpy( subkeys_ptr
[num_subkeys
], data
->keys
[i
].name
);
2813 /* asking for the subkeys of some key */
2814 /* subkey paths are stored in the key name using '\' as the delimiter */
2816 for ( i
=0; i
<data
->num_keys
; i
++ ) {
2817 if ( StrnCaseCmp(data
->keys
[i
].name
, key
, strlen(key
)) == 0 ) {
2819 /* if we found the exact key, then break */
2820 key_len
= strlen( key
);
2821 if ( strlen(data
->keys
[i
].name
) == key_len
)
2824 /* get subkey path */
2826 p
= data
->keys
[i
].name
+ key_len
;
2829 fstrcpy( subkeyname
, p
);
2830 if ( (p
= strchr( subkeyname
, '\\' )) )
2833 /* don't add a key more than once */
2835 for ( j
=0; j
<num_subkeys
; j
++ ) {
2836 if ( strequal( subkeys_ptr
[j
], subkeyname
) )
2840 if ( j
!= num_subkeys
)
2843 /* found a match, so allocate space and copy the name */
2845 if ( !(subkeys_ptr
= SMB_REALLOC_ARRAY( subkeys_ptr
, fstring
, num_subkeys
+2)) ) {
2846 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
2851 fstrcpy( subkeys_ptr
[num_subkeys
], subkeyname
);
2857 /* return error if the key was not found */
2859 if ( i
== data
->num_keys
) {
2860 SAFE_FREE(subkeys_ptr
);
2865 /* tag off the end */
2868 fstrcpy(subkeys_ptr
[num_subkeys
], "" );
2870 *subkeys
= subkeys_ptr
;
2876 static void map_sz_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2879 smb_ucs2_t conv_str
[1024];
2882 regval_ctr_delvalue(ctr
, val_name
);
2883 str_size
= push_ucs2(NULL
, conv_str
, sz
, sizeof(conv_str
),
2884 STR_TERMINATE
| STR_NOALIGN
);
2885 regval_ctr_addvalue(ctr
, val_name
, REG_SZ
,
2886 (char *) conv_str
, str_size
);
2889 static void map_dword_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2892 regval_ctr_delvalue(ctr
, val_name
);
2893 regval_ctr_addvalue(ctr
, val_name
, REG_DWORD
,
2894 (char *) &dword
, sizeof(dword
));
2897 static void map_bool_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2900 uint8 bin_bool
= (b
? 1 : 0);
2901 regval_ctr_delvalue(ctr
, val_name
);
2902 regval_ctr_addvalue(ctr
, val_name
, REG_BINARY
,
2903 (char *) &bin_bool
, sizeof(bin_bool
));
2906 static void map_single_multi_sz_into_ctr(REGVAL_CTR
*ctr
, const char *val_name
,
2907 const char *multi_sz
)
2909 smb_ucs2_t
*conv_strs
= NULL
;
2912 /* a multi-sz has to have a null string terminator, i.e., the last
2913 string must be followed by two nulls */
2914 str_size
= strlen(multi_sz
) + 2;
2915 conv_strs
= SMB_CALLOC_ARRAY(smb_ucs2_t
, str_size
);
2920 /* Change to byte units. */
2921 str_size
*= sizeof(smb_ucs2_t
);
2922 push_ucs2(NULL
, conv_strs
, multi_sz
, str_size
,
2923 STR_TERMINATE
| STR_NOALIGN
);
2925 regval_ctr_delvalue(ctr
, val_name
);
2926 regval_ctr_addvalue(ctr
, val_name
, REG_MULTI_SZ
,
2927 (char *) conv_strs
, str_size
);
2928 safe_free(conv_strs
);
2932 /****************************************************************************
2933 * Map the NT_PRINTER_INFO_LEVEL_2 data into DsSpooler keys for publishing.
2935 * @param info2 NT_PRINTER_INFO_LEVEL_2 describing printer - gets modified
2936 * @return BOOL indicating success or failure
2937 ***************************************************************************/
2939 static BOOL
map_nt_printer_info2_to_dsspooler(NT_PRINTER_INFO_LEVEL_2
*info2
)
2941 REGVAL_CTR
*ctr
= NULL
;
2944 char *allocated_string
= NULL
;
2945 const char *ascii_str
;
2948 if ((i
= lookup_printerkey(info2
->data
, SPOOL_DSSPOOLER_KEY
)) < 0)
2949 i
= add_new_printer_key(info2
->data
, SPOOL_DSSPOOLER_KEY
);
2950 ctr
= info2
->data
->keys
[i
].values
;
2952 map_sz_into_ctr(ctr
, SPOOL_REG_PRINTERNAME
, info2
->sharename
);
2953 map_sz_into_ctr(ctr
, SPOOL_REG_SHORTSERVERNAME
, global_myname());
2955 /* we make the assumption that the netbios name is the same
2956 as the DNS name sinc ethe former will be what we used to
2959 if ( get_mydnsdomname( dnssuffix
) )
2960 fstr_sprintf( longname
, "%s.%s", global_myname(), dnssuffix
);
2962 fstrcpy( longname
, global_myname() );
2964 map_sz_into_ctr(ctr
, SPOOL_REG_SERVERNAME
, longname
);
2966 asprintf(&allocated_string
, "\\\\%s\\%s", longname
, info2
->sharename
);
2967 map_sz_into_ctr(ctr
, SPOOL_REG_UNCNAME
, allocated_string
);
2968 SAFE_FREE(allocated_string
);
2970 map_dword_into_ctr(ctr
, SPOOL_REG_VERSIONNUMBER
, 4);
2971 map_sz_into_ctr(ctr
, SPOOL_REG_DRIVERNAME
, info2
->drivername
);
2972 map_sz_into_ctr(ctr
, SPOOL_REG_LOCATION
, info2
->location
);
2973 map_sz_into_ctr(ctr
, SPOOL_REG_DESCRIPTION
, info2
->comment
);
2974 map_single_multi_sz_into_ctr(ctr
, SPOOL_REG_PORTNAME
, info2
->portname
);
2975 map_sz_into_ctr(ctr
, SPOOL_REG_PRINTSEPARATORFILE
, info2
->sepfile
);
2976 map_dword_into_ctr(ctr
, SPOOL_REG_PRINTSTARTTIME
, info2
->starttime
);
2977 map_dword_into_ctr(ctr
, SPOOL_REG_PRINTENDTIME
, info2
->untiltime
);
2978 map_dword_into_ctr(ctr
, SPOOL_REG_PRIORITY
, info2
->priority
);
2980 map_bool_into_ctr(ctr
, SPOOL_REG_PRINTKEEPPRINTEDJOBS
,
2981 (info2
->attributes
&
2982 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS
));
2984 switch (info2
->attributes
& 0x3) {
2986 ascii_str
= SPOOL_REGVAL_PRINTWHILESPOOLING
;
2989 ascii_str
= SPOOL_REGVAL_PRINTAFTERSPOOLED
;
2992 ascii_str
= SPOOL_REGVAL_PRINTDIRECT
;
2995 ascii_str
= "unknown";
2997 map_sz_into_ctr(ctr
, SPOOL_REG_PRINTSPOOLING
, ascii_str
);
3002 /*****************************************************************
3003 ****************************************************************/
3005 static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2
*info2
,
3009 REGVAL_CTR
*ctr
=NULL
;
3010 UNISTR2 unistr_guid
;
3012 /* find the DsSpooler key */
3013 if ((i
= lookup_printerkey(info2
->data
, SPOOL_DSSPOOLER_KEY
)) < 0)
3014 i
= add_new_printer_key(info2
->data
, SPOOL_DSSPOOLER_KEY
);
3015 ctr
= info2
->data
->keys
[i
].values
;
3017 regval_ctr_delvalue(ctr
, "objectGUID");
3019 /* We used to store this as a REG_BINARY but that causes
3022 ZERO_STRUCT( unistr_guid
);
3023 init_unistr2( &unistr_guid
, smb_uuid_string_static(guid
),
3024 UNI_STR_TERMINATE
);
3026 regval_ctr_addvalue(ctr
, "objectGUID", REG_SZ
,
3027 (char *)unistr_guid
.buffer
,
3028 unistr_guid
.uni_max_len
*2);
3032 static WERROR
nt_printer_publish_ads(ADS_STRUCT
*ads
,
3033 NT_PRINTER_INFO_LEVEL
*printer
)
3037 char *prt_dn
= NULL
, *srv_dn
, *srv_cn_0
, *srv_cn_escaped
, *sharename_escaped
;
3038 char *srv_dn_utf8
, **srv_cn_utf8
;
3041 const char *attrs
[] = {"objectGUID", NULL
};
3043 WERROR win_rc
= WERR_OK
;
3045 DEBUG(5, ("publishing printer %s\n", printer
->info_2
->printername
));
3047 /* figure out where to publish */
3048 ads_find_machine_acct(ads
, &res
, global_myname());
3050 /* We use ldap_get_dn here as we need the answer
3051 * in utf8 to call ldap_explode_dn(). JRA. */
3053 srv_dn_utf8
= ldap_get_dn((LDAP
*)ads
->ld
, (LDAPMessage
*)res
);
3056 return WERR_SERVER_UNAVAILABLE
;
3058 ads_msgfree(ads
, res
);
3059 srv_cn_utf8
= ldap_explode_dn(srv_dn_utf8
, 1);
3061 ldap_memfree(srv_dn_utf8
);
3063 return WERR_SERVER_UNAVAILABLE
;
3065 /* Now convert to CH_UNIX. */
3066 if (pull_utf8_allocate(&srv_dn
, srv_dn_utf8
) == (size_t)-1) {
3067 ldap_memfree(srv_dn_utf8
);
3068 ldap_memfree(srv_cn_utf8
);
3070 return WERR_SERVER_UNAVAILABLE
;
3072 if (pull_utf8_allocate(&srv_cn_0
, srv_cn_utf8
[0]) == (size_t)-1) {
3073 ldap_memfree(srv_dn_utf8
);
3074 ldap_memfree(srv_cn_utf8
);
3077 return WERR_SERVER_UNAVAILABLE
;
3080 ldap_memfree(srv_dn_utf8
);
3081 ldap_memfree(srv_cn_utf8
);
3083 srv_cn_escaped
= escape_rdn_val_string_alloc(srv_cn_0
);
3084 if (!srv_cn_escaped
) {
3085 SAFE_FREE(srv_cn_0
);
3086 ldap_memfree(srv_dn_utf8
);
3088 return WERR_SERVER_UNAVAILABLE
;
3090 sharename_escaped
= escape_rdn_val_string_alloc(printer
->info_2
->sharename
);
3091 if (!sharename_escaped
) {
3092 SAFE_FREE(srv_cn_escaped
);
3093 SAFE_FREE(srv_cn_0
);
3094 ldap_memfree(srv_dn_utf8
);
3096 return WERR_SERVER_UNAVAILABLE
;
3100 asprintf(&prt_dn
, "cn=%s-%s,%s", srv_cn_escaped
, sharename_escaped
, srv_dn
);
3103 SAFE_FREE(srv_cn_0
);
3104 SAFE_FREE(srv_cn_escaped
);
3105 SAFE_FREE(sharename_escaped
);
3107 /* build the ads mods */
3108 ctx
= talloc_init("nt_printer_publish_ads");
3114 mods
= ads_init_mods(ctx
);
3118 talloc_destroy(ctx
);
3122 get_local_printer_publishing_data(ctx
, &mods
, printer
->info_2
->data
);
3123 ads_mod_str(ctx
, &mods
, SPOOL_REG_PRINTERNAME
,
3124 printer
->info_2
->sharename
);
3127 ads_rc
= ads_mod_printer_entry(ads
, prt_dn
, ctx
, &mods
);
3128 if (ads_rc
.err
.rc
== LDAP_NO_SUCH_OBJECT
)
3129 ads_rc
= ads_add_printer_entry(ads
, prt_dn
, ctx
, &mods
);
3131 if (!ADS_ERR_OK(ads_rc
))
3132 DEBUG(3, ("error publishing %s: %s\n", printer
->info_2
->sharename
, ads_errstr(ads_rc
)));
3134 talloc_destroy(ctx
);
3136 /* retreive the guid and store it locally */
3137 if (ADS_ERR_OK(ads_search_dn(ads
, &res
, prt_dn
, attrs
))) {
3139 ads_pull_guid(ads
, res
, &guid
);
3140 ads_msgfree(ads
, res
);
3141 store_printer_guid(printer
->info_2
, guid
);
3142 win_rc
= mod_a_printer(printer
, 2);
3149 static WERROR
nt_printer_unpublish_ads(ADS_STRUCT
*ads
,
3150 NT_PRINTER_INFO_LEVEL
*printer
)
3154 char *prt_dn
= NULL
;
3156 DEBUG(5, ("unpublishing printer %s\n", printer
->info_2
->printername
));
3158 /* remove the printer from the directory */
3159 ads_rc
= ads_find_printer_on_server(ads
, &res
,
3160 printer
->info_2
->sharename
, global_myname());
3162 if (ADS_ERR_OK(ads_rc
) && ads_count_replies(ads
, res
)) {
3163 prt_dn
= ads_get_dn(ads
, res
);
3165 ads_msgfree(ads
, res
);
3168 ads_rc
= ads_del_dn(ads
, prt_dn
);
3169 ads_memfree(ads
, prt_dn
);
3172 ads_msgfree(ads
, res
);
3176 /****************************************************************************
3177 * Publish a printer in the directory
3179 * @param snum describing printer service
3180 * @return WERROR indicating status of publishing
3181 ***************************************************************************/
3183 WERROR
nt_printer_publish(Printer_entry
*print_hnd
, int snum
, int action
)
3186 ADS_STRUCT
*ads
= NULL
;
3187 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3190 win_rc
= get_a_printer(print_hnd
, &printer
, 2, lp_servicename(snum
));
3191 if (!W_ERROR_IS_OK(win_rc
))
3195 case SPOOL_DS_PUBLISH
:
3196 case SPOOL_DS_UPDATE
:
3197 /* set the DsSpooler info and attributes */
3198 if (!(map_nt_printer_info2_to_dsspooler(printer
->info_2
))) {
3199 win_rc
= WERR_NOMEM
;
3203 printer
->info_2
->attributes
|= PRINTER_ATTRIBUTE_PUBLISHED
;
3205 case SPOOL_DS_UNPUBLISH
:
3206 printer
->info_2
->attributes
^= PRINTER_ATTRIBUTE_PUBLISHED
;
3209 win_rc
= WERR_NOT_SUPPORTED
;
3213 win_rc
= mod_a_printer(printer
, 2);
3214 if (!W_ERROR_IS_OK(win_rc
)) {
3215 DEBUG(3, ("err %d saving data\n", W_ERROR_V(win_rc
)));
3219 ads
= ads_init(lp_realm(), lp_workgroup(), NULL
);
3221 DEBUG(3, ("ads_init() failed\n"));
3222 win_rc
= WERR_SERVER_UNAVAILABLE
;
3225 setenv(KRB5_ENV_CCNAME
, "MEMORY:prtpub_cache", 1);
3226 SAFE_FREE(ads
->auth
.password
);
3227 ads
->auth
.password
= secrets_fetch_machine_password(lp_workgroup(),
3230 /* ads_connect() will find the DC for us */
3231 ads_rc
= ads_connect(ads
);
3232 if (!ADS_ERR_OK(ads_rc
)) {
3233 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc
)));
3234 win_rc
= WERR_ACCESS_DENIED
;
3239 case SPOOL_DS_PUBLISH
:
3240 case SPOOL_DS_UPDATE
:
3241 win_rc
= nt_printer_publish_ads(ads
, printer
);
3243 case SPOOL_DS_UNPUBLISH
:
3244 win_rc
= nt_printer_unpublish_ads(ads
, printer
);
3249 free_a_printer(&printer
, 2);
3254 WERROR
check_published_printers(void)
3257 ADS_STRUCT
*ads
= NULL
;
3259 int n_services
= lp_numservices();
3260 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3262 ads
= ads_init(lp_realm(), lp_workgroup(), NULL
);
3264 DEBUG(3, ("ads_init() failed\n"));
3265 return WERR_SERVER_UNAVAILABLE
;
3267 setenv(KRB5_ENV_CCNAME
, "MEMORY:prtpub_cache", 1);
3268 SAFE_FREE(ads
->auth
.password
);
3269 ads
->auth
.password
= secrets_fetch_machine_password(lp_workgroup(),
3272 /* ads_connect() will find the DC for us */
3273 ads_rc
= ads_connect(ads
);
3274 if (!ADS_ERR_OK(ads_rc
)) {
3275 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc
)));
3277 ads_kdestroy("MEMORY:prtpub_cache");
3278 return WERR_ACCESS_DENIED
;
3281 for (snum
= 0; snum
< n_services
; snum
++) {
3282 if (!(lp_snum_ok(snum
) && lp_print_ok(snum
)))
3285 if (W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2,
3286 lp_servicename(snum
))) &&
3287 (printer
->info_2
->attributes
& PRINTER_ATTRIBUTE_PUBLISHED
))
3288 nt_printer_publish_ads(ads
, printer
);
3290 free_a_printer(&printer
, 2);
3294 ads_kdestroy("MEMORY:prtpub_cache");
3298 BOOL
is_printer_published(Printer_entry
*print_hnd
, int snum
,
3301 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
3303 REGISTRY_VALUE
*guid_val
;
3308 win_rc
= get_a_printer(print_hnd
, &printer
, 2, lp_servicename(snum
));
3310 if (!W_ERROR_IS_OK(win_rc
) ||
3311 !(printer
->info_2
->attributes
& PRINTER_ATTRIBUTE_PUBLISHED
) ||
3312 ((i
= lookup_printerkey(printer
->info_2
->data
, SPOOL_DSSPOOLER_KEY
)) < 0) ||
3313 !(ctr
= printer
->info_2
->data
->keys
[i
].values
) ||
3314 !(guid_val
= regval_ctr_getvalue(ctr
, "objectGUID")))
3316 free_a_printer(&printer
, 2);
3320 /* fetching printer guids really ought to be a separate function. */
3325 /* We used to store the guid as REG_BINARY, then swapped
3326 to REG_SZ for Vista compatibility so check for both */
3328 switch ( regval_type(guid_val
) ){
3330 rpcstr_pull( guid_str
, regval_data_p(guid_val
),
3331 sizeof(guid_str
)-1, -1, STR_TERMINATE
);
3332 ret
= smb_string_to_uuid( guid_str
, guid
);
3335 if ( regval_size(guid_val
) != sizeof(struct GUID
) ) {
3339 memcpy(guid
, regval_data_p(guid_val
), sizeof(struct GUID
));
3342 DEBUG(0,("is_printer_published: GUID value stored as "
3343 "invaluid type (%d)\n", regval_type(guid_val
) ));
3348 free_a_printer(&printer
, 2);
3352 WERROR
nt_printer_publish(Printer_entry
*print_hnd
, int snum
, int action
)
3357 WERROR
check_published_printers(void)
3362 BOOL
is_printer_published(Printer_entry
*print_hnd
, int snum
,
3367 #endif /* HAVE_ADS */
3369 /****************************************************************************
3370 ***************************************************************************/
3372 WERROR
delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
)
3374 NT_PRINTER_DATA
*data
;
3376 int removed_keys
= 0;
3380 empty_slot
= data
->num_keys
;
3383 return WERR_INVALID_PARAM
;
3385 /* remove all keys */
3387 if ( !strlen(key
) ) {
3389 TALLOC_FREE( data
);
3393 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
3399 /* remove a specific key (and all subkeys) */
3401 for ( i
=0; i
<data
->num_keys
; i
++ ) {
3402 if ( StrnCaseCmp( data
->keys
[i
].name
, key
, strlen(key
)) == 0 ) {
3403 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
3404 data
->keys
[i
].name
));
3406 TALLOC_FREE( data
->keys
[i
].name
);
3407 TALLOC_FREE( data
->keys
[i
].values
);
3409 /* mark the slot as empty */
3411 ZERO_STRUCTP( &data
->keys
[i
] );
3415 /* find the first empty slot */
3417 for ( i
=0; i
<data
->num_keys
; i
++ ) {
3418 if ( !data
->keys
[i
].name
) {
3425 if ( i
== data
->num_keys
)
3426 /* nothing was removed */
3427 return WERR_INVALID_PARAM
;
3429 /* move everything down */
3431 for ( i
=empty_slot
+1; i
<data
->num_keys
; i
++ ) {
3432 if ( data
->keys
[i
].name
) {
3433 memcpy( &data
->keys
[empty_slot
], &data
->keys
[i
], sizeof(NT_PRINTER_KEY
) );
3434 ZERO_STRUCTP( &data
->keys
[i
] );
3442 data
->num_keys
-= removed_keys
;
3444 /* sanity check to see if anything is left */
3446 if ( !data
->num_keys
) {
3447 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2
->printername
));
3449 SAFE_FREE( data
->keys
);
3450 ZERO_STRUCTP( data
);
3456 /****************************************************************************
3457 ***************************************************************************/
3459 WERROR
delete_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
, const char *value
)
3461 WERROR result
= WERR_OK
;
3464 /* we must have names on non-zero length */
3466 if ( !key
|| !*key
|| !value
|| !*value
)
3467 return WERR_INVALID_NAME
;
3469 /* find the printer key first */
3471 key_index
= lookup_printerkey( p2
->data
, key
);
3472 if ( key_index
== -1 )
3475 /* make sure the value exists so we can return the correct error code */
3477 if ( !regval_ctr_getvalue( p2
->data
->keys
[key_index
].values
, value
) )
3478 return WERR_BADFILE
;
3480 regval_ctr_delvalue( p2
->data
->keys
[key_index
].values
, value
);
3482 DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
3488 /****************************************************************************
3489 ***************************************************************************/
3491 WERROR
add_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
, const char *value
,
3492 uint32 type
, uint8
*data
, int real_len
)
3494 WERROR result
= WERR_OK
;
3497 /* we must have names on non-zero length */
3499 if ( !key
|| !*key
|| !value
|| !*value
)
3500 return WERR_INVALID_NAME
;
3502 /* find the printer key first */
3504 key_index
= lookup_printerkey( p2
->data
, key
);
3505 if ( key_index
== -1 )
3506 key_index
= add_new_printer_key( p2
->data
, key
);
3508 if ( key_index
== -1 )
3511 regval_ctr_addvalue( p2
->data
->keys
[key_index
].values
, value
,
3512 type
, (const char *)data
, real_len
);
3514 DEBUG(8,("add_printer_data: Added key => [%s], value => [%s], type=> [%d], size => [%d]\n",
3515 key
, value
, type
, real_len
));
3520 /****************************************************************************
3521 ***************************************************************************/
3523 REGISTRY_VALUE
* get_printer_data( NT_PRINTER_INFO_LEVEL_2
*p2
, const char *key
, const char *value
)
3527 if ( (key_index
= lookup_printerkey( p2
->data
, key
)) == -1 )
3530 DEBUG(8,("get_printer_data: Attempting to lookup key => [%s], value => [%s]\n",
3533 return regval_ctr_getvalue( p2
->data
->keys
[key_index
].values
, value
);
3536 /****************************************************************************
3537 Unpack a list of registry values frem the TDB
3538 ***************************************************************************/
3540 static int unpack_values(NT_PRINTER_DATA
*printer_data
, char *buf
, int buflen
)
3544 pstring string
, valuename
, keyname
;
3548 REGISTRY_VALUE
*regval_p
;
3551 /* add the "PrinterDriverData" key first for performance reasons */
3553 add_new_printer_key( printer_data
, SPOOL_PRINTERDATA_KEY
);
3555 /* loop and unpack the rest of the registry values */
3559 /* check to see if there are any more registry values */
3562 len
+= tdb_unpack(buf
+len
, buflen
-len
, "p", ®val_p
);
3566 /* unpack the next regval */
3568 len
+= tdb_unpack(buf
+len
, buflen
-len
, "fdB",
3574 /* lookup for subkey names which have a type of REG_NONE */
3575 /* there's no data with this entry */
3577 if ( type
== REG_NONE
) {
3578 if ( (key_index
=lookup_printerkey( printer_data
, string
)) == -1 )
3579 add_new_printer_key( printer_data
, string
);
3584 * break of the keyname from the value name.
3585 * Valuenames can have embedded '\'s so be careful.
3586 * only support one level of keys. See the
3587 * "Konica Fiery S300 50C-K v1.1. enu" 2k driver.
3591 str
= strchr_m( string
, '\\');
3593 /* Put in "PrinterDriverData" is no key specified */
3596 pstrcpy( keyname
, SPOOL_PRINTERDATA_KEY
);
3597 pstrcpy( valuename
, string
);
3601 pstrcpy( keyname
, string
);
3602 pstrcpy( valuename
, str
+1 );
3605 /* see if we need a new key */
3607 if ( (key_index
=lookup_printerkey( printer_data
, keyname
)) == -1 )
3608 key_index
= add_new_printer_key( printer_data
, keyname
);
3610 if ( key_index
== -1 ) {
3611 DEBUG(0,("unpack_values: Failed to allocate a new key [%s]!\n",
3616 DEBUG(8,("specific: [%s:%s], len: %d\n", keyname
, valuename
, size
));
3618 /* Vista doesn't like unknown REG_BINARY values in DsSpooler.
3619 Thanks to Martin Zielinski for the hint. */
3621 if ( type
== REG_BINARY
&&
3622 strequal( keyname
, SPOOL_DSSPOOLER_KEY
) &&
3623 strequal( valuename
, "objectGUID" ) )
3626 UNISTR2 unistr_guid
;
3628 ZERO_STRUCT( unistr_guid
);
3630 /* convert the GUID to a UNICODE string */
3632 memcpy( &guid
, data_p
, sizeof(struct GUID
) );
3634 init_unistr2( &unistr_guid
, smb_uuid_string_static(guid
),
3635 UNI_STR_TERMINATE
);
3637 regval_ctr_addvalue( printer_data
->keys
[key_index
].values
,
3639 (const char *)unistr_guid
.buffer
,
3640 unistr_guid
.uni_str_len
*2 );
3645 regval_ctr_addvalue( printer_data
->keys
[key_index
].values
,
3646 valuename
, type
, (const char *)data_p
,
3651 SAFE_FREE(data_p
); /* 'B' option to tdbpack does a malloc() */
3658 /****************************************************************************
3659 ***************************************************************************/
3661 static void map_to_os2_driver(fstring drivername
)
3663 static BOOL initialised
=False
;
3664 static fstring last_from
,last_to
;
3665 char *mapfile
= lp_os2_driver_map();
3666 char **lines
= NULL
;
3670 if (!strlen(drivername
))
3677 *last_from
= *last_to
= 0;
3681 if (strequal(drivername
,last_from
)) {
3682 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",drivername
,last_to
));
3683 fstrcpy(drivername
,last_to
);
3687 lines
= file_lines_load(mapfile
, &numlines
,0);
3688 if (numlines
== 0 || lines
== NULL
) {
3689 DEBUG(0,("No entries in OS/2 driver map %s\n",mapfile
));
3694 DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile
));
3696 for( i
= 0; i
< numlines
; i
++) {
3697 char *nt_name
= lines
[i
];
3698 char *os2_name
= strchr(nt_name
,'=');
3705 while (isspace(*nt_name
))
3708 if (!*nt_name
|| strchr("#;",*nt_name
))
3712 int l
= strlen(nt_name
);
3713 while (l
&& isspace(nt_name
[l
-1])) {
3719 while (isspace(*os2_name
))
3723 int l
= strlen(os2_name
);
3724 while (l
&& isspace(os2_name
[l
-1])) {
3730 if (strequal(nt_name
,drivername
)) {
3731 DEBUG(3,("Mapped windows driver %s to os2 driver%s\n",drivername
,os2_name
));
3732 fstrcpy(last_from
,drivername
);
3733 fstrcpy(last_to
,os2_name
);
3734 fstrcpy(drivername
,os2_name
);
3735 file_lines_free(lines
);
3740 file_lines_free(lines
);
3743 /****************************************************************************
3744 Get a default printer info 2 struct.
3745 ****************************************************************************/
3746 static WERROR
get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2
*info
, const char *servername
, const char* sharename
)
3748 int snum
= lp_servicenumber(sharename
);
3750 slprintf(info
->servername
, sizeof(info
->servername
)-1, "\\\\%s", servername
);
3751 slprintf(info
->printername
, sizeof(info
->printername
)-1, "\\\\%s\\%s",
3752 servername
, sharename
);
3753 fstrcpy(info
->sharename
, sharename
);
3754 fstrcpy(info
->portname
, SAMBA_PRINTER_PORT_NAME
);
3756 /* by setting the driver name to an empty string, a local NT admin
3757 can now run the **local** APW to install a local printer driver
3758 for a Samba shared printer in 2.2. Without this, drivers **must** be
3759 installed on the Samba server for NT clients --jerry */
3760 #if 0 /* JERRY --do not uncomment-- */
3761 if (!*info
->drivername
)
3762 fstrcpy(info
->drivername
, "NO DRIVER AVAILABLE FOR THIS PRINTER");
3766 DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info
->drivername
));
3768 pstrcpy(info
->comment
, "");
3769 fstrcpy(info
->printprocessor
, "winprint");
3770 fstrcpy(info
->datatype
, "RAW");
3773 if ( (enum printing_types
)lp_printing(snum
) == PRINT_CUPS
) {
3774 /* Pull the location and comment strings from cups if we don't
3776 if ( !strlen(info
->location
) || !strlen(info
->comment
) )
3777 cups_pull_comment_location( info
);
3781 info
->attributes
= PRINTER_ATTRIBUTE_SAMBA
;
3783 info
->starttime
= 0; /* Minutes since 12:00am GMT */
3784 info
->untiltime
= 0; /* Minutes since 12:00am GMT */
3786 info
->default_priority
= 1;
3787 info
->setuptime
= (uint32
)time(NULL
);
3790 * I changed this as I think it is better to have a generic
3791 * DEVMODE than to crash Win2k explorer.exe --jerry
3792 * See the HP Deskjet 990c Win2k drivers for an example.
3794 * However the default devmode appears to cause problems
3795 * with the HP CLJ 8500 PCL driver. Hence the addition of
3796 * the "default devmode" parameter --jerry 22/01/2002
3799 if (lp_default_devmode(snum
)) {
3800 if ((info
->devmode
= construct_nt_devicemode(info
->printername
)) == NULL
) {
3804 info
->devmode
= NULL
;
3807 if (!nt_printing_getsec(info
, sharename
, &info
->secdesc_buf
)) {
3815 free_nt_devicemode(&info
->devmode
);
3817 return WERR_ACCESS_DENIED
;
3820 /****************************************************************************
3821 ****************************************************************************/
3822 static WERROR
get_a_printer_2(NT_PRINTER_INFO_LEVEL_2
*info
, const char *servername
, const char *sharename
)
3825 int snum
= lp_servicenumber(sharename
);
3826 TDB_DATA kbuf
, dbuf
;
3827 fstring printername
;
3828 char adevice
[MAXDEVICENAME
];
3830 kbuf
= make_printer_tdbkey( sharename
);
3832 dbuf
= tdb_fetch(tdb_printers
, kbuf
);
3834 return get_a_printer_2_default(info
, servername
, sharename
);
3837 len
+= tdb_unpack(dbuf
.dptr
+len
, dbuf
.dsize
-len
, "dddddddddddfffffPfffff",
3840 &info
->default_priority
,
3847 &info
->c_setprinter
,
3857 info
->printprocessor
,
3861 /* Samba has to have shared raw drivers. */
3862 info
->attributes
|= PRINTER_ATTRIBUTE_SAMBA
;
3863 info
->attributes
&= ~PRINTER_ATTRIBUTE_NOT_SAMBA
;
3865 /* Restore the stripped strings. */
3866 slprintf(info
->servername
, sizeof(info
->servername
)-1, "\\\\%s", servername
);
3868 if ( lp_force_printername(snum
) ) {
3869 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\%s", servername
, sharename
);
3871 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\%s", servername
, info
->printername
);
3874 fstrcpy(info
->printername
, printername
);
3877 if ( (enum printing_types
)lp_printing(snum
) == PRINT_CUPS
) {
3878 /* Pull the location and comment strings from cups if we don't
3880 if ( !strlen(info
->location
) || !strlen(info
->comment
) )
3881 cups_pull_comment_location( info
);
3885 len
+= unpack_devicemode(&info
->devmode
,dbuf
.dptr
+len
, dbuf
.dsize
-len
);
3888 * Some client drivers freak out if there is a NULL devmode
3889 * (probably the driver is not checking before accessing
3890 * the devmode pointer) --jerry
3892 * See comments in get_a_printer_2_default()
3895 if (lp_default_devmode(snum
) && !info
->devmode
) {
3896 DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
3898 info
->devmode
= construct_nt_devicemode(printername
);
3901 slprintf( adevice
, sizeof(adevice
), "%s", info
->printername
);
3902 if (info
->devmode
) {
3903 fstrcpy(info
->devmode
->devicename
, adevice
);
3906 if ( !(info
->data
= TALLOC_ZERO_P( info
, NT_PRINTER_DATA
)) ) {
3907 DEBUG(0,("unpack_values: talloc() failed!\n"));
3908 SAFE_FREE(dbuf
.dptr
);
3911 len
+= unpack_values( info
->data
, dbuf
.dptr
+len
, dbuf
.dsize
-len
);
3913 /* This will get the current RPC talloc context, but we should be
3914 passing this as a parameter... fixme... JRA ! */
3916 if (!nt_printing_getsec(info
, sharename
, &info
->secdesc_buf
)) {
3917 SAFE_FREE(dbuf
.dptr
);
3921 /* Fix for OS/2 drivers. */
3923 if (get_remote_arch() == RA_OS2
) {
3924 map_to_os2_driver(info
->drivername
);
3927 SAFE_FREE(dbuf
.dptr
);
3929 DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
3930 sharename
, info
->printername
, info
->drivername
));
3935 /****************************************************************************
3936 Debugging function, dump at level 6 the struct in the logs.
3937 ****************************************************************************/
3938 static uint32
dump_a_printer(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
3941 NT_PRINTER_INFO_LEVEL_2
*info2
;
3943 DEBUG(106,("Dumping printer at level [%d]\n", level
));
3948 if (printer
->info_2
== NULL
)
3952 info2
=printer
->info_2
;
3954 DEBUGADD(106,("attributes:[%d]\n", info2
->attributes
));
3955 DEBUGADD(106,("priority:[%d]\n", info2
->priority
));
3956 DEBUGADD(106,("default_priority:[%d]\n", info2
->default_priority
));
3957 DEBUGADD(106,("starttime:[%d]\n", info2
->starttime
));
3958 DEBUGADD(106,("untiltime:[%d]\n", info2
->untiltime
));
3959 DEBUGADD(106,("status:[%d]\n", info2
->status
));
3960 DEBUGADD(106,("cjobs:[%d]\n", info2
->cjobs
));
3961 DEBUGADD(106,("averageppm:[%d]\n", info2
->averageppm
));
3962 DEBUGADD(106,("changeid:[%d]\n", info2
->changeid
));
3963 DEBUGADD(106,("c_setprinter:[%d]\n", info2
->c_setprinter
));
3964 DEBUGADD(106,("setuptime:[%d]\n", info2
->setuptime
));
3966 DEBUGADD(106,("servername:[%s]\n", info2
->servername
));
3967 DEBUGADD(106,("printername:[%s]\n", info2
->printername
));
3968 DEBUGADD(106,("sharename:[%s]\n", info2
->sharename
));
3969 DEBUGADD(106,("portname:[%s]\n", info2
->portname
));
3970 DEBUGADD(106,("drivername:[%s]\n", info2
->drivername
));
3971 DEBUGADD(106,("comment:[%s]\n", info2
->comment
));
3972 DEBUGADD(106,("location:[%s]\n", info2
->location
));
3973 DEBUGADD(106,("sepfile:[%s]\n", info2
->sepfile
));
3974 DEBUGADD(106,("printprocessor:[%s]\n", info2
->printprocessor
));
3975 DEBUGADD(106,("datatype:[%s]\n", info2
->datatype
));
3976 DEBUGADD(106,("parameters:[%s]\n", info2
->parameters
));
3982 DEBUGADD(106,("dump_a_printer: Level %u not implemented\n", (unsigned int)level
));
3990 /****************************************************************************
3991 Update the changeid time.
3992 This is SO NASTY as some drivers need this to change, others need it
3993 static. This value will change every second, and I must hope that this
3994 is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
3996 ****************************************************************************/
3998 static uint32
rev_changeid(void)
4002 get_process_uptime(&tv
);
4005 /* Return changeid as msec since spooler restart */
4006 return tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
4009 * This setting seems to work well but is too untested
4010 * to replace the above calculation. Left in for experiementation
4011 * of the reader --jerry (Tue Mar 12 09:15:05 CST 2002)
4013 return tv
.tv_sec
* 10 + tv
.tv_usec
/ 100000;
4019 * The function below are the high level ones.
4020 * only those ones must be called from the spoolss code.
4024 /****************************************************************************
4025 Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
4026 ****************************************************************************/
4028 WERROR
mod_a_printer(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
4032 dump_a_printer(printer
, level
);
4038 * Update the changestamp. Emperical tests show that the
4039 * ChangeID is always updated,but c_setprinter is
4040 * global spooler variable (not per printer).
4043 /* ChangeID **must** be increasing over the lifetime
4044 of client's spoolss service in order for the
4045 client's cache to show updates */
4047 printer
->info_2
->changeid
= rev_changeid();
4050 * Because one day someone will ask:
4051 * NT->NT An admin connection to a remote
4052 * printer show changes imeediately in
4053 * the properities dialog
4055 * A non-admin connection will only show the
4056 * changes after viewing the properites page
4057 * 2 times. Seems to be related to a
4058 * race condition in the client between the spooler
4059 * updating the local cache and the Explorer.exe GUI
4060 * actually displaying the properties.
4062 * This is fixed in Win2k. admin/non-admin
4063 * connections both display changes immediately.
4068 result
=update_a_printer_2(printer
->info_2
);
4073 result
=WERR_UNKNOWN_LEVEL
;
4080 /****************************************************************************
4081 Initialize printer devmode & data with previously saved driver init values.
4082 ****************************************************************************/
4084 static BOOL
set_driver_init_2( NT_PRINTER_INFO_LEVEL_2
*info_ptr
)
4088 TDB_DATA kbuf
, dbuf
;
4089 NT_PRINTER_INFO_LEVEL_2 info
;
4095 * Delete any printer data 'values' already set. When called for driver
4096 * replace, there will generally be some, but during an add printer, there
4097 * should not be any (if there are delete them).
4100 if ( info_ptr
->data
)
4101 delete_all_printer_data( info_ptr
, "" );
4103 slprintf(key
, sizeof(key
)-1, "%s%s", DRIVER_INIT_PREFIX
, info_ptr
->drivername
);
4106 kbuf
.dsize
= strlen(key
)+1;
4108 dbuf
= tdb_fetch(tdb_drivers
, kbuf
);
4111 * When changing to a driver that has no init info in the tdb, remove
4112 * the previous drivers init info and leave the new on blank.
4114 free_nt_devicemode(&info_ptr
->devmode
);
4119 * Get the saved DEVMODE..
4122 len
+= unpack_devicemode(&info
.devmode
,dbuf
.dptr
+len
, dbuf
.dsize
-len
);
4125 * The saved DEVMODE contains the devicename from the printer used during
4126 * the initialization save. Change it to reflect the new printer.
4129 if ( info
.devmode
) {
4130 ZERO_STRUCT(info
.devmode
->devicename
);
4131 fstrcpy(info
.devmode
->devicename
, info_ptr
->printername
);
4135 * NT/2k does not change out the entire DeviceMode of a printer
4136 * when changing the driver. Only the driverextra, private, &
4137 * driverversion fields. --jerry (Thu Mar 14 08:58:43 CST 2002)
4139 * Later examination revealed that Windows NT/2k does reset the
4140 * the printer's device mode, bit **only** when you change a
4141 * property of the device mode such as the page orientation.
4146 /* Bind the saved DEVMODE to the new the printer */
4148 free_nt_devicemode(&info_ptr
->devmode
);
4149 info_ptr
->devmode
= info
.devmode
;
4151 DEBUG(10,("set_driver_init_2: Set printer [%s] init %s DEVMODE for driver [%s]\n",
4152 info_ptr
->printername
, info_ptr
->devmode
?"VALID":"NULL", info_ptr
->drivername
));
4154 /* Add the printer data 'values' to the new printer */
4156 if ( !(info_ptr
->data
= TALLOC_ZERO_P( info_ptr
, NT_PRINTER_DATA
)) ) {
4157 DEBUG(0,("set_driver_init_2: talloc() failed!\n"));
4161 len
+= unpack_values( info_ptr
->data
, dbuf
.dptr
+len
, dbuf
.dsize
-len
);
4164 SAFE_FREE(dbuf
.dptr
);
4169 /****************************************************************************
4170 Initialize printer devmode & data with previously saved driver init values.
4171 When a printer is created using AddPrinter, the drivername bound to the
4172 printer is used to lookup previously saved driver initialization info, which
4173 is bound to the new printer.
4174 ****************************************************************************/
4176 BOOL
set_driver_init(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
4178 BOOL result
= False
;
4182 result
= set_driver_init_2(printer
->info_2
);
4186 DEBUG(0,("set_driver_init: Programmer's error! Unknown driver_init level [%d]\n",
4194 /****************************************************************************
4195 Delete driver init data stored for a specified driver
4196 ****************************************************************************/
4198 BOOL
del_driver_init(char *drivername
)
4203 if (!drivername
|| !*drivername
) {
4204 DEBUG(3,("del_driver_init: No drivername specified!\n"));
4208 slprintf(key
, sizeof(key
)-1, "%s%s", DRIVER_INIT_PREFIX
, drivername
);
4211 kbuf
.dsize
= strlen(key
)+1;
4213 DEBUG(6,("del_driver_init: Removing driver init data for [%s]\n", drivername
));
4215 return (tdb_delete(tdb_drivers
, kbuf
) == 0);
4218 /****************************************************************************
4219 Pack up the DEVMODE and values for a printer into a 'driver init' entry
4220 in the tdb. Note: this is different from the driver entry and the printer
4221 entry. There should be a single driver init entry for each driver regardless
4222 of whether it was installed from NT or 2K. Technically, they should be
4223 different, but they work out to the same struct.
4224 ****************************************************************************/
4226 static uint32
update_driver_init_2(NT_PRINTER_INFO_LEVEL_2
*info
)
4230 int buflen
, len
, ret
;
4231 TDB_DATA kbuf
, dbuf
;
4238 len
+= pack_devicemode(info
->devmode
, buf
+len
, buflen
-len
);
4240 len
+= pack_values( info
->data
, buf
+len
, buflen
-len
);
4243 buf
= (char *)SMB_REALLOC(buf
, len
);
4245 DEBUG(0, ("update_driver_init_2: failed to enlarge buffer!\n"));
4253 slprintf(key
, sizeof(key
)-1, "%s%s", DRIVER_INIT_PREFIX
, info
->drivername
);
4256 kbuf
.dsize
= strlen(key
)+1;
4260 ret
= tdb_store(tdb_drivers
, kbuf
, dbuf
, TDB_REPLACE
);
4264 DEBUG(8, ("update_driver_init_2: error updating printer init to tdb on disk\n"));
4268 DEBUG(10,("update_driver_init_2: Saved printer [%s] init DEVMODE & values for driver [%s]\n",
4269 info
->sharename
, info
->drivername
));
4274 /****************************************************************************
4275 Update (i.e. save) the driver init info (DEVMODE and values) for a printer
4276 ****************************************************************************/
4278 static uint32
update_driver_init(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
)
4282 dump_a_printer(printer
, level
);
4286 result
= update_driver_init_2(printer
->info_2
);
4296 /****************************************************************************
4297 Convert the printer data value, a REG_BINARY array, into an initialization
4298 DEVMODE. Note: the array must be parsed as if it was a DEVMODE in an rpc...
4299 got to keep the endians happy :).
4300 ****************************************************************************/
4302 static BOOL
convert_driver_init( TALLOC_CTX
*ctx
, NT_DEVICEMODE
*nt_devmode
, uint8
*data
, uint32 data_len
)
4304 BOOL result
= False
;
4308 ZERO_STRUCT(devmode
);
4310 prs_init(&ps
, 0, ctx
, UNMARSHALL
);
4311 ps
.data_p
= (char *)data
;
4312 ps
.buffer_size
= data_len
;
4314 if (spoolss_io_devmode("phantom DEVMODE", &ps
, 0, &devmode
))
4315 result
= convert_devicemode("", &devmode
, &nt_devmode
);
4317 DEBUG(10,("convert_driver_init: error parsing DEVMODE\n"));
4322 /****************************************************************************
4323 Set the DRIVER_INIT info in the tdb. Requires Win32 client code that:
4325 1. Use the driver's config DLL to this UNC printername and:
4326 a. Call DrvPrintEvent with PRINTER_EVENT_INITIALIZE
4327 b. Call DrvConvertDevMode with CDM_DRIVER_DEFAULT to get default DEVMODE
4328 2. Call SetPrinterData with the 'magic' key and the DEVMODE as data.
4330 The last step triggers saving the "driver initialization" information for
4331 this printer into the tdb. Later, new printers that use this driver will
4332 have this initialization information bound to them. This simulates the
4333 driver initialization, as if it had run on the Samba server (as it would
4336 The Win32 client side code requirement sucks! But until we can run arbitrary
4337 Win32 printer driver code on any Unix that Samba runs on, we are stuck with it.
4339 It would have been easier to use SetPrinter because all the UNMARSHALLING of
4340 the DEVMODE is done there, but 2K/XP clients do not set the DEVMODE... think
4341 about it and you will realize why. JRR 010720
4342 ****************************************************************************/
4344 static WERROR
save_driver_init_2(NT_PRINTER_INFO_LEVEL
*printer
, uint8
*data
, uint32 data_len
)
4346 WERROR status
= WERR_OK
;
4347 TALLOC_CTX
*ctx
= NULL
;
4348 NT_DEVICEMODE
*nt_devmode
= NULL
;
4349 NT_DEVICEMODE
*tmp_devmode
= printer
->info_2
->devmode
;
4352 * When the DEVMODE is already set on the printer, don't try to unpack it.
4354 DEBUG(8,("save_driver_init_2: Enter...\n"));
4356 if ( !printer
->info_2
->devmode
&& data_len
) {
4358 * Set devmode on printer info, so entire printer initialization can be
4362 if ((ctx
= talloc_init("save_driver_init_2")) == NULL
)
4365 if ((nt_devmode
= SMB_MALLOC_P(NT_DEVICEMODE
)) == NULL
) {
4366 status
= WERR_NOMEM
;
4370 ZERO_STRUCTP(nt_devmode
);
4373 * The DEVMODE is held in the 'data' component of the param in raw binary.
4374 * Convert it to to a devmode structure
4376 if ( !convert_driver_init( ctx
, nt_devmode
, data
, data_len
)) {
4377 DEBUG(10,("save_driver_init_2: error converting DEVMODE\n"));
4378 status
= WERR_INVALID_PARAM
;
4382 printer
->info_2
->devmode
= nt_devmode
;
4386 * Pack up and add (or update) the DEVMODE and any current printer data to
4387 * a 'driver init' element in the tdb
4391 if ( update_driver_init(printer
, 2) != 0 ) {
4392 DEBUG(10,("save_driver_init_2: error updating DEVMODE\n"));
4393 status
= WERR_NOMEM
;
4398 * If driver initialization info was successfully saved, set the current
4399 * printer to match it. This allows initialization of the current printer
4400 * as well as the driver.
4402 status
= mod_a_printer(printer
, 2);
4403 if (!W_ERROR_IS_OK(status
)) {
4404 DEBUG(10,("save_driver_init_2: error setting DEVMODE on printer [%s]\n",
4405 printer
->info_2
->printername
));
4409 talloc_destroy(ctx
);
4410 free_nt_devicemode( &nt_devmode
);
4412 printer
->info_2
->devmode
= tmp_devmode
;
4417 /****************************************************************************
4418 Update the driver init info (DEVMODE and specifics) for a printer
4419 ****************************************************************************/
4421 WERROR
save_driver_init(NT_PRINTER_INFO_LEVEL
*printer
, uint32 level
, uint8
*data
, uint32 data_len
)
4423 WERROR status
= WERR_OK
;
4427 status
= save_driver_init_2( printer
, data
, data_len
);
4430 status
= WERR_UNKNOWN_LEVEL
;
4437 /****************************************************************************
4438 Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
4440 Previously the code had a memory allocation problem because it always
4441 used the TALLOC_CTX from the Printer_entry*. This context lasts
4442 as a long as the original handle is open. So if the client made a lot
4443 of getprinter[data]() calls, the memory usage would climb. Now we use
4444 a short lived TALLOC_CTX for printer_info_2 objects returned. We
4445 still use the Printer_entry->ctx for maintaining the cache copy though
4446 since that object must live as long as the handle by definition.
4449 ****************************************************************************/
4451 WERROR
get_a_printer( Printer_entry
*print_hnd
, NT_PRINTER_INFO_LEVEL
**pp_printer
, uint32 level
,
4452 const char *sharename
)
4457 DEBUG(10,("get_a_printer: [%s] level %u\n", sharename
, (unsigned int)level
));
4459 if ( !(*pp_printer
= TALLOC_ZERO_P(NULL
, NT_PRINTER_INFO_LEVEL
)) ) {
4460 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4466 if ( !((*pp_printer
)->info_2
= TALLOC_ZERO_P(*pp_printer
, NT_PRINTER_INFO_LEVEL_2
)) ) {
4467 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4468 TALLOC_FREE( *pp_printer
);
4473 fstrcpy( servername
, print_hnd
->servername
);
4475 fstrcpy( servername
, "%L" );
4476 standard_sub_basic( "", "", servername
,
4477 sizeof(servername
)-1 );
4480 result
= get_a_printer_2( (*pp_printer
)->info_2
, servername
, sharename
);
4483 /* we have a new printer now. Save it with this handle */
4485 if ( !W_ERROR_IS_OK(result
) ) {
4486 TALLOC_FREE( *pp_printer
);
4487 DEBUG(10,("get_a_printer: [%s] level %u returning %s\n",
4488 sharename
, (unsigned int)level
, dos_errstr(result
)));
4492 dump_a_printer( *pp_printer
, level
);
4497 TALLOC_FREE( *pp_printer
);
4498 return WERR_UNKNOWN_LEVEL
;
4504 /****************************************************************************
4505 Deletes a NT_PRINTER_INFO_LEVEL struct.
4506 ****************************************************************************/
4508 uint32
free_a_printer(NT_PRINTER_INFO_LEVEL
**pp_printer
, uint32 level
)
4510 NT_PRINTER_INFO_LEVEL
*printer
= *pp_printer
;
4517 if ( printer
->info_2
)
4518 free_nt_printer_info_level_2(&printer
->info_2
);
4522 DEBUG(0,("free_a_printer: unknown level! [%d]\n", level
));
4526 TALLOC_FREE(*pp_printer
);
4531 /****************************************************************************
4532 ****************************************************************************/
4533 uint32
add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver
, uint32 level
)
4536 DEBUG(104,("adding a printer at level [%d]\n", level
));
4537 dump_a_printer_driver(driver
, level
);
4541 result
=add_a_printer_driver_3(driver
.info_3
);
4545 result
=add_a_printer_driver_6(driver
.info_6
);
4555 /****************************************************************************
4556 ****************************************************************************/
4558 WERROR
get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL
*driver
, uint32 level
,
4559 fstring drivername
, const char *architecture
, uint32 version
)
4565 /* Sometime we just want any version of the driver */
4567 if ( version
== DRIVER_ANY_VERSION
) {
4568 /* look for Win2k first and then for NT4 */
4569 result
= get_a_printer_driver_3(&driver
->info_3
, drivername
,
4572 if ( !W_ERROR_IS_OK(result
) ) {
4573 result
= get_a_printer_driver_3( &driver
->info_3
,
4574 drivername
, architecture
, 2 );
4577 result
= get_a_printer_driver_3(&driver
->info_3
, drivername
,
4578 architecture
, version
);
4587 if (W_ERROR_IS_OK(result
))
4588 dump_a_printer_driver(*driver
, level
);
4593 /****************************************************************************
4594 ****************************************************************************/
4595 uint32
free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver
, uint32 level
)
4602 NT_PRINTER_DRIVER_INFO_LEVEL_3
*info3
;
4603 if (driver
.info_3
!= NULL
)
4605 info3
=driver
.info_3
;
4606 SAFE_FREE(info3
->dependentfiles
);
4607 ZERO_STRUCTP(info3
);
4617 NT_PRINTER_DRIVER_INFO_LEVEL_6
*info6
;
4618 if (driver
.info_6
!= NULL
) {
4619 info6
=driver
.info_6
;
4620 SAFE_FREE(info6
->dependentfiles
);
4621 SAFE_FREE(info6
->previousnames
);
4622 ZERO_STRUCTP(info6
);
4638 /****************************************************************************
4639 Determine whether or not a particular driver is currently assigned
4641 ****************************************************************************/
4643 BOOL
printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info_3
)
4646 int n_services
= lp_numservices();
4647 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
4648 BOOL in_use
= False
;
4653 DEBUG(10,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
4655 /* loop through the printers.tdb and check for the drivername */
4657 for (snum
=0; snum
<n_services
&& !in_use
; snum
++) {
4658 if ( !(lp_snum_ok(snum
) && lp_print_ok(snum
) ) )
4661 if ( !W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, lp_servicename(snum
))) )
4664 if ( strequal(info_3
->name
, printer
->info_2
->drivername
) )
4667 free_a_printer( &printer
, 2 );
4670 DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
4673 NT_PRINTER_DRIVER_INFO_LEVEL d
;
4676 DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", info_3
->name
));
4678 /* we can still remove the driver if there is one of
4679 "Windows NT x86" version 2 or 3 left */
4681 if ( !strequal( "Windows NT x86", info_3
->environment
) ) {
4682 werr
= get_a_printer_driver( &d
, 3, info_3
->name
, "Windows NT x86", DRIVER_ANY_VERSION
);
4685 switch ( info_3
->cversion
) {
4687 werr
= get_a_printer_driver( &d
, 3, info_3
->name
, "Windows NT x86", 3 );
4690 werr
= get_a_printer_driver( &d
, 3, info_3
->name
, "Windows NT x86", 2 );
4693 DEBUG(0,("printer_driver_in_use: ERROR! unknown driver version (%d)\n",
4695 werr
= WERR_UNKNOWN_PRINTER_DRIVER
;
4700 /* now check the error code */
4702 if ( W_ERROR_IS_OK(werr
) ) {
4703 /* it's ok to remove the driver, we have other architctures left */
4705 free_a_printer_driver( d
, 3 );
4709 /* report that the driver is not in use by default */
4715 /**********************************************************************
4716 Check to see if a ogiven file is in use by *info
4717 *********************************************************************/
4719 static BOOL
drv_file_in_use( char* file
, NT_PRINTER_DRIVER_INFO_LEVEL_3
*info
)
4726 if ( strequal(file
, info
->driverpath
) )
4729 if ( strequal(file
, info
->datafile
) )
4732 if ( strequal(file
, info
->configfile
) )
4735 if ( strequal(file
, info
->helpfile
) )
4738 /* see of there are any dependent files to examine */
4740 if ( !info
->dependentfiles
)
4743 while ( *info
->dependentfiles
[i
] ) {
4744 if ( strequal(file
, info
->dependentfiles
[i
]) )
4753 /**********************************************************************
4754 Utility function to remove the dependent file pointed to by the
4755 input parameter from the list
4756 *********************************************************************/
4758 static void trim_dependent_file( fstring files
[], int idx
)
4761 /* bump everything down a slot */
4763 while( *files
[idx
+1] ) {
4764 fstrcpy( files
[idx
], files
[idx
+1] );
4773 /**********************************************************************
4774 Check if any of the files used by src are also used by drv
4775 *********************************************************************/
4777 static BOOL
trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3
*src
,
4778 NT_PRINTER_DRIVER_INFO_LEVEL_3
*drv
)
4780 BOOL in_use
= False
;
4786 /* check each file. Remove it from the src structure if it overlaps */
4788 if ( drv_file_in_use(src
->driverpath
, drv
) ) {
4790 DEBUG(10,("Removing driverfile [%s] from list\n", src
->driverpath
));
4791 fstrcpy( src
->driverpath
, "" );
4794 if ( drv_file_in_use(src
->datafile
, drv
) ) {
4796 DEBUG(10,("Removing datafile [%s] from list\n", src
->datafile
));
4797 fstrcpy( src
->datafile
, "" );
4800 if ( drv_file_in_use(src
->configfile
, drv
) ) {
4802 DEBUG(10,("Removing configfile [%s] from list\n", src
->configfile
));
4803 fstrcpy( src
->configfile
, "" );
4806 if ( drv_file_in_use(src
->helpfile
, drv
) ) {
4808 DEBUG(10,("Removing helpfile [%s] from list\n", src
->helpfile
));
4809 fstrcpy( src
->helpfile
, "" );
4812 /* are there any dependentfiles to examine? */
4814 if ( !src
->dependentfiles
)
4817 while ( *src
->dependentfiles
[i
] ) {
4818 if ( drv_file_in_use(src
->dependentfiles
[i
], drv
) ) {
4820 DEBUG(10,("Removing [%s] from dependent file list\n", src
->dependentfiles
[i
]));
4821 trim_dependent_file( src
->dependentfiles
, i
);
4829 /****************************************************************************
4830 Determine whether or not a particular driver files are currently being
4831 used by any other driver.
4833 Return value is True if any files were in use by other drivers
4834 and False otherwise.
4836 Upon return, *info has been modified to only contain the driver files
4837 which are not in use
4838 ****************************************************************************/
4840 BOOL
printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info
)
4845 fstring
*list
= NULL
;
4846 NT_PRINTER_DRIVER_INFO_LEVEL driver
;
4851 version
= info
->cversion
;
4853 /* loop over all driver versions */
4855 DEBUG(5,("printer_driver_files_in_use: Beginning search through ntdrivers.tdb...\n"));
4857 /* get the list of drivers */
4860 ndrivers
= get_ntdrivers(&list
, info
->environment
, version
);
4862 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
4863 ndrivers
, info
->environment
, version
));
4865 /* check each driver for overlap in files */
4867 for (i
=0; i
<ndrivers
; i
++) {
4868 DEBUGADD(5,("\tdriver: [%s]\n", list
[i
]));
4870 ZERO_STRUCT(driver
);
4872 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver
, 3, list
[i
], info
->environment
, version
)) ) {
4877 /* check if d2 uses any files from d1 */
4878 /* only if this is a different driver than the one being deleted */
4880 if ( !strequal(info
->name
, driver
.info_3
->name
) ) {
4881 if ( trim_overlap_drv_files(info
, driver
.info_3
) ) {
4882 free_a_printer_driver(driver
, 3);
4888 free_a_printer_driver(driver
, 3);
4893 DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
4895 driver
.info_3
= info
;
4897 if ( DEBUGLEVEL
>= 20 )
4898 dump_a_printer_driver( driver
, 3 );
4903 /****************************************************************************
4904 Actually delete the driver files. Make sure that
4905 printer_driver_files_in_use() return False before calling
4907 ****************************************************************************/
4909 static BOOL
delete_driver_files( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info_3
, struct current_user
*user
)
4914 connection_struct
*conn
;
4923 DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3
->name
, info_3
->cversion
));
4926 * Connect to the print$ share under the same account as the
4927 * user connected to the rpc pipe. Note we must be root to
4931 null_pw
= data_blob( NULL
, 0 );
4932 fstrcpy(res_type
, "A:");
4934 conn
= make_connection_with_chdir( "print$", null_pw
, res_type
, user
->vuid
, &nt_status
);
4938 DEBUG(0,("delete_driver_files: Unable to connect\n"));
4942 if ( !CAN_WRITE(conn
) ) {
4943 DEBUG(3,("delete_driver_files: Cannot delete print driver when [print$] is read-only\n"));
4947 /* Save who we are - we are temporarily becoming the connection user. */
4949 if ( !become_user(conn
, conn
->vuid
) ) {
4950 DEBUG(0,("delete_driver_files: Can't become user!\n"));
4954 /* now delete the files; must strip the '\print$' string from
4957 if ( *info_3
->driverpath
) {
4958 if ( (s
= strchr( &info_3
->driverpath
[1], '\\' )) != NULL
) {
4960 driver_unix_convert(file
, conn
, NULL
, &st
);
4961 DEBUG(10,("deleting driverfile [%s]\n", s
));
4962 unlink_internals(conn
, 0, file
, False
, False
);
4966 if ( *info_3
->configfile
) {
4967 if ( (s
= strchr( &info_3
->configfile
[1], '\\' )) != NULL
) {
4969 driver_unix_convert(file
, conn
, NULL
, &st
);
4970 DEBUG(10,("deleting configfile [%s]\n", s
));
4971 unlink_internals(conn
, 0, file
, False
, False
);
4975 if ( *info_3
->datafile
) {
4976 if ( (s
= strchr( &info_3
->datafile
[1], '\\' )) != NULL
) {
4978 driver_unix_convert(file
, conn
, NULL
, &st
);
4979 DEBUG(10,("deleting datafile [%s]\n", s
));
4980 unlink_internals(conn
, 0, file
, False
, False
);
4984 if ( *info_3
->helpfile
) {
4985 if ( (s
= strchr( &info_3
->helpfile
[1], '\\' )) != NULL
) {
4987 driver_unix_convert(file
, conn
, NULL
, &st
);
4988 DEBUG(10,("deleting helpfile [%s]\n", s
));
4989 unlink_internals(conn
, 0, file
, False
, False
);
4993 /* check if we are done removing files */
4995 if ( info_3
->dependentfiles
) {
4996 while ( info_3
->dependentfiles
[i
][0] ) {
4999 /* bypass the "\print$" portion of the path */
5001 if ( (p
= strchr( info_3
->dependentfiles
[i
]+1, '\\' )) != NULL
) {
5003 driver_unix_convert(file
, conn
, NULL
, &st
);
5004 DEBUG(10,("deleting dependent file [%s]\n", file
));
5005 unlink_internals(conn
, 0, file
, False
, False
);
5017 /****************************************************************************
5018 Remove a printer driver from the TDB. This assumes that the the driver was
5019 previously looked up.
5020 ***************************************************************************/
5022 WERROR
delete_printer_driver( NT_PRINTER_DRIVER_INFO_LEVEL_3
*info_3
, struct current_user
*user
,
5023 uint32 version
, BOOL delete_files
)
5027 TDB_DATA kbuf
, dbuf
;
5028 NT_PRINTER_DRIVER_INFO_LEVEL ctr
;
5030 /* delete the tdb data first */
5032 arch
= get_short_archi(info_3
->environment
);
5034 return WERR_UNKNOWN_PRINTER_DRIVER
;
5036 slprintf(key
, sizeof(key
)-1, "%s%s/%d/%s", DRIVERS_PREFIX
,
5037 arch
, version
, info_3
->name
);
5039 DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
5040 key
, delete_files
? "TRUE" : "FALSE" ));
5042 ctr
.info_3
= info_3
;
5043 dump_a_printer_driver( ctr
, 3 );
5046 kbuf
.dsize
=strlen(key
)+1;
5048 /* check if the driver actually exists for this environment */
5050 dbuf
= tdb_fetch( tdb_drivers
, kbuf
);
5052 DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key
));
5053 return WERR_UNKNOWN_PRINTER_DRIVER
;
5056 SAFE_FREE( dbuf
.dptr
);
5058 /* ok... the driver exists so the delete should return success */
5060 if (tdb_delete(tdb_drivers
, kbuf
) == -1) {
5061 DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key
));
5062 return WERR_ACCESS_DENIED
;
5066 * now delete any associated files if delete_files == True
5067 * even if this part failes, we return succes because the
5068 * driver doesn not exist any more
5072 delete_driver_files( info_3
, user
);
5075 DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key
));
5080 /****************************************************************************
5081 Store a security desc for a printer.
5082 ****************************************************************************/
5084 WERROR
nt_printing_setsec(const char *sharename
, SEC_DESC_BUF
*secdesc_ctr
)
5086 SEC_DESC_BUF
*new_secdesc_ctr
= NULL
;
5087 SEC_DESC_BUF
*old_secdesc_ctr
= NULL
;
5089 TALLOC_CTX
*mem_ctx
= NULL
;
5093 mem_ctx
= talloc_init("nt_printing_setsec");
5094 if (mem_ctx
== NULL
)
5097 /* The old owner and group sids of the security descriptor are not
5098 present when new ACEs are added or removed by changing printer
5099 permissions through NT. If they are NULL in the new security
5100 descriptor then copy them over from the old one. */
5102 if (!secdesc_ctr
->sec
->owner_sid
|| !secdesc_ctr
->sec
->group_sid
) {
5103 DOM_SID
*owner_sid
, *group_sid
;
5104 SEC_ACL
*dacl
, *sacl
;
5105 SEC_DESC
*psd
= NULL
;
5108 if (!nt_printing_getsec(mem_ctx
, sharename
, &old_secdesc_ctr
)) {
5109 status
= WERR_NOMEM
;
5113 /* Pick out correct owner and group sids */
5115 owner_sid
= secdesc_ctr
->sec
->owner_sid
?
5116 secdesc_ctr
->sec
->owner_sid
:
5117 old_secdesc_ctr
->sec
->owner_sid
;
5119 group_sid
= secdesc_ctr
->sec
->group_sid
?
5120 secdesc_ctr
->sec
->group_sid
:
5121 old_secdesc_ctr
->sec
->group_sid
;
5123 dacl
= secdesc_ctr
->sec
->dacl
?
5124 secdesc_ctr
->sec
->dacl
:
5125 old_secdesc_ctr
->sec
->dacl
;
5127 sacl
= secdesc_ctr
->sec
->sacl
?
5128 secdesc_ctr
->sec
->sacl
:
5129 old_secdesc_ctr
->sec
->sacl
;
5131 /* Make a deep copy of the security descriptor */
5133 psd
= make_sec_desc(mem_ctx
, secdesc_ctr
->sec
->revision
, secdesc_ctr
->sec
->type
,
5134 owner_sid
, group_sid
,
5140 status
= WERR_NOMEM
;
5144 new_secdesc_ctr
= make_sec_desc_buf(mem_ctx
, size
, psd
);
5147 if (!new_secdesc_ctr
) {
5148 new_secdesc_ctr
= secdesc_ctr
;
5151 /* Store the security descriptor in a tdb */
5153 prs_init(&ps
, (uint32
)sec_desc_size(new_secdesc_ctr
->sec
) +
5154 sizeof(SEC_DESC_BUF
), mem_ctx
, MARSHALL
);
5156 if (!sec_io_desc_buf("nt_printing_setsec", &new_secdesc_ctr
,
5158 status
= WERR_BADFUNC
;
5162 key
= make_printers_secdesc_tdbkey( sharename
);
5164 if (tdb_prs_store(tdb_printers
, key
, &ps
)==0) {
5167 DEBUG(1,("Failed to store secdesc for %s\n", sharename
));
5168 status
= WERR_BADFUNC
;
5171 /* Free malloc'ed memory */
5177 talloc_destroy(mem_ctx
);
5181 /****************************************************************************
5182 Construct a default security descriptor buffer for a printer.
5183 ****************************************************************************/
5185 static SEC_DESC_BUF
*construct_default_printer_sdb(TALLOC_CTX
*ctx
)
5187 SEC_ACE ace
[5]; /* max number of ace entries */
5190 SEC_ACL
*psa
= NULL
;
5191 SEC_DESC_BUF
*sdb
= NULL
;
5192 SEC_DESC
*psd
= NULL
;
5196 /* Create an ACE where Everyone is allowed to print */
5198 init_sec_access(&sa
, PRINTER_ACE_PRINT
);
5199 init_sec_ace(&ace
[i
++], &global_sid_World
, SEC_ACE_TYPE_ACCESS_ALLOWED
,
5200 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5202 /* Add the domain admins group if we are a DC */
5205 DOM_SID domadmins_sid
;
5207 sid_copy(&domadmins_sid
, get_global_sam_sid());
5208 sid_append_rid(&domadmins_sid
, DOMAIN_GROUP_RID_ADMINS
);
5210 init_sec_access(&sa
, PRINTER_ACE_FULL_CONTROL
);
5211 init_sec_ace(&ace
[i
++], &domadmins_sid
,
5212 SEC_ACE_TYPE_ACCESS_ALLOWED
, sa
,
5213 SEC_ACE_FLAG_OBJECT_INHERIT
| SEC_ACE_FLAG_INHERIT_ONLY
);
5214 init_sec_ace(&ace
[i
++], &domadmins_sid
, SEC_ACE_TYPE_ACCESS_ALLOWED
,
5215 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5217 else if (secrets_fetch_domain_sid(lp_workgroup(), &adm_sid
)) {
5218 sid_append_rid(&adm_sid
, DOMAIN_USER_RID_ADMIN
);
5220 init_sec_access(&sa
, PRINTER_ACE_FULL_CONTROL
);
5221 init_sec_ace(&ace
[i
++], &adm_sid
,
5222 SEC_ACE_TYPE_ACCESS_ALLOWED
, sa
,
5223 SEC_ACE_FLAG_OBJECT_INHERIT
| SEC_ACE_FLAG_INHERIT_ONLY
);
5224 init_sec_ace(&ace
[i
++], &adm_sid
, SEC_ACE_TYPE_ACCESS_ALLOWED
,
5225 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5228 /* add BUILTIN\Administrators as FULL CONTROL */
5230 init_sec_access(&sa
, PRINTER_ACE_FULL_CONTROL
);
5231 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Administrators
,
5232 SEC_ACE_TYPE_ACCESS_ALLOWED
, sa
,
5233 SEC_ACE_FLAG_OBJECT_INHERIT
| SEC_ACE_FLAG_INHERIT_ONLY
);
5234 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Administrators
,
5235 SEC_ACE_TYPE_ACCESS_ALLOWED
,
5236 sa
, SEC_ACE_FLAG_CONTAINER_INHERIT
);
5238 /* Make the security descriptor owned by the BUILTIN\Administrators */
5240 /* The ACL revision number in rpc_secdesc.h differs from the one
5241 created by NT when setting ACE entries in printer
5242 descriptors. NT4 complains about the property being edited by a
5245 if ((psa
= make_sec_acl(ctx
, NT4_ACL_REVISION
, i
, ace
)) != NULL
) {
5246 psd
= make_sec_desc(ctx
, SEC_DESC_REVISION
, SEC_DESC_SELF_RELATIVE
,
5247 &global_sid_Builtin_Administrators
,
5248 &global_sid_Builtin_Administrators
,
5249 NULL
, psa
, &sd_size
);
5253 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
5257 sdb
= make_sec_desc_buf(ctx
, sd_size
, psd
);
5259 DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
5260 (unsigned int)sd_size
));
5265 /****************************************************************************
5266 Get a security desc for a printer.
5267 ****************************************************************************/
5269 BOOL
nt_printing_getsec(TALLOC_CTX
*ctx
, const char *sharename
, SEC_DESC_BUF
**secdesc_ctr
)
5275 if (strlen(sharename
) > 2 && (temp
= strchr(sharename
+ 2, '\\'))) {
5276 sharename
= temp
+ 1;
5281 /* Fetch security descriptor from tdb */
5283 key
= make_printers_secdesc_tdbkey( sharename
);
5285 if (tdb_prs_fetch(tdb_printers
, key
, &ps
, ctx
)!=0 ||
5286 !sec_io_desc_buf("nt_printing_getsec", secdesc_ctr
, &ps
, 1)) {
5290 DEBUG(4,("using default secdesc for %s\n", sharename
));
5292 if (!(*secdesc_ctr
= construct_default_printer_sdb(ctx
))) {
5296 /* Save default security descriptor for later */
5298 prs_init(&ps
, (uint32
)sec_desc_size((*secdesc_ctr
)->sec
) +
5299 sizeof(SEC_DESC_BUF
), ctx
, MARSHALL
);
5301 if (sec_io_desc_buf("nt_printing_getsec", secdesc_ctr
, &ps
, 1)) {
5302 tdb_prs_store(tdb_printers
, key
, &ps
);
5312 /* If security descriptor is owned by S-1-1-0 and winbindd is up,
5313 this security descriptor has been created when winbindd was
5314 down. Take ownership of security descriptor. */
5316 if (sid_equal((*secdesc_ctr
)->sec
->owner_sid
, &global_sid_World
)) {
5319 /* Change sd owner to workgroup administrator */
5321 if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid
)) {
5322 SEC_DESC_BUF
*new_secdesc_ctr
= NULL
;
5323 SEC_DESC
*psd
= NULL
;
5328 sid_append_rid(&owner_sid
, DOMAIN_USER_RID_ADMIN
);
5330 psd
= make_sec_desc(ctx
, (*secdesc_ctr
)->sec
->revision
, (*secdesc_ctr
)->sec
->type
,
5332 (*secdesc_ctr
)->sec
->group_sid
,
5333 (*secdesc_ctr
)->sec
->sacl
,
5334 (*secdesc_ctr
)->sec
->dacl
,
5341 new_secdesc_ctr
= make_sec_desc_buf(ctx
, size
, psd
);
5342 if (!new_secdesc_ctr
) {
5346 /* Swap with other one */
5348 *secdesc_ctr
= new_secdesc_ctr
;
5352 nt_printing_setsec(sharename
, *secdesc_ctr
);
5356 if (DEBUGLEVEL
>= 10) {
5357 SEC_ACL
*the_acl
= (*secdesc_ctr
)->sec
->dacl
;
5360 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5361 sharename
, the_acl
->num_aces
));
5363 for (i
= 0; i
< the_acl
->num_aces
; i
++) {
5366 sid_to_string(sid_str
, &the_acl
->aces
[i
].trustee
);
5368 DEBUG(10, ("%s %d %d 0x%08x\n", sid_str
,
5369 the_acl
->aces
[i
].type
, the_acl
->aces
[i
].flags
,
5370 the_acl
->aces
[i
].access_mask
));
5379 1: level not implemented
5380 2: file doesn't exist
5381 3: can't allocate memory
5382 4: can't free memory
5383 5: non existant struct
5387 A printer and a printer driver are 2 different things.
5388 NT manages them separatelly, Samba does the same.
5389 Why ? Simply because it's easier and it makes sense !
5391 Now explanation: You have 3 printers behind your samba server,
5392 2 of them are the same make and model (laser A and B). But laser B
5393 has an 3000 sheet feeder and laser A doesn't such an option.
5394 Your third printer is an old dot-matrix model for the accounting :-).
5396 If the /usr/local/samba/lib directory (default dir), you will have
5397 5 files to describe all of this.
5399 3 files for the printers (1 by printer):
5402 NTprinter_accounting
5403 2 files for the drivers (1 for the laser and 1 for the dot matrix)
5404 NTdriver_printer model X
5405 NTdriver_printer model Y
5407 jfm: I should use this comment for the text file to explain
5408 same thing for the forms BTW.
5409 Je devrais mettre mes commentaires en francais, ca serait mieux :-)
5413 /* Convert generic access rights to printer object specific access rights.
5414 It turns out that NT4 security descriptors use generic access rights and
5415 NT5 the object specific ones. */
5417 void map_printer_permissions(SEC_DESC
*sd
)
5421 for (i
= 0; sd
->dacl
&& i
< sd
->dacl
->num_aces
; i
++) {
5422 se_map_generic(&sd
->dacl
->aces
[i
].access_mask
,
5423 &printer_generic_mapping
);
5427 /****************************************************************************
5428 Check a user has permissions to perform the given operation. We use the
5429 permission constants defined in include/rpc_spoolss.h to check the various
5430 actions we perform when checking printer access.
5432 PRINTER_ACCESS_ADMINISTER:
5433 print_queue_pause, print_queue_resume, update_printer_sec,
5434 update_printer, spoolss_addprinterex_level_2,
5435 _spoolss_setprinterdata
5440 JOB_ACCESS_ADMINISTER:
5441 print_job_delete, print_job_pause, print_job_resume,
5444 Try access control in the following order (for performance reasons):
5445 1) root ans SE_PRINT_OPERATOR can do anything (easy check)
5446 2) check security descriptor (bit comparisons in memory)
5447 3) "printer admins" (may result in numerous calls to winbind)
5449 ****************************************************************************/
5450 BOOL
print_access_check(struct current_user
*user
, int snum
, int access_type
)
5452 SEC_DESC_BUF
*secdesc
= NULL
;
5453 uint32 access_granted
;
5457 TALLOC_CTX
*mem_ctx
= NULL
;
5458 SE_PRIV se_printop
= SE_PRINT_OPERATOR
;
5460 /* If user is NULL then use the current_user structure */
5463 user
= ¤t_user
;
5465 /* Always allow root or SE_PRINT_OPERATROR to do anything */
5467 if ( user
->ut
.uid
== 0 || user_has_privileges(user
->nt_user_token
, &se_printop
) ) {
5471 /* Get printer name */
5473 pname
= PRINTERNAME(snum
);
5475 if (!pname
|| !*pname
) {
5480 /* Get printer security descriptor */
5482 if(!(mem_ctx
= talloc_init("print_access_check"))) {
5487 if (!nt_printing_getsec(mem_ctx
, pname
, &secdesc
)) {
5488 talloc_destroy(mem_ctx
);
5493 if (access_type
== JOB_ACCESS_ADMINISTER
) {
5494 SEC_DESC_BUF
*parent_secdesc
= secdesc
;
5496 /* Create a child security descriptor to check permissions
5497 against. This is because print jobs are child objects
5498 objects of a printer. */
5500 secdesc
= se_create_child_secdesc(mem_ctx
, parent_secdesc
->sec
, False
);
5503 talloc_destroy(mem_ctx
);
5508 /* Now this is the bit that really confuses me. The access
5509 type needs to be changed from JOB_ACCESS_ADMINISTER to
5510 PRINTER_ACCESS_ADMINISTER for this to work. Something
5511 to do with the child (job) object becoming like a
5514 access_type
= PRINTER_ACCESS_ADMINISTER
;
5519 map_printer_permissions(secdesc
->sec
);
5521 result
= se_access_check(secdesc
->sec
, user
->nt_user_token
, access_type
,
5522 &access_granted
, &status
);
5524 DEBUG(4, ("access check was %s\n", result
? "SUCCESS" : "FAILURE"));
5526 /* see if we need to try the printer admin list */
5528 if ((access_granted
== 0) &&
5529 (token_contains_name_in_list(uidtoname(user
->ut
.uid
), NULL
,
5530 user
->nt_user_token
,
5531 lp_printer_admin(snum
)))) {
5532 talloc_destroy(mem_ctx
);
5536 talloc_destroy(mem_ctx
);
5545 /****************************************************************************
5546 Check the time parameters allow a print operation.
5547 *****************************************************************************/
5549 BOOL
print_time_access_check(const char *servicename
)
5551 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
5553 time_t now
= time(NULL
);
5557 if (!W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, servicename
)))
5560 if (printer
->info_2
->starttime
== 0 && printer
->info_2
->untiltime
== 0)
5564 mins
= (uint32
)t
->tm_hour
*60 + (uint32
)t
->tm_min
;
5566 if (mins
>= printer
->info_2
->starttime
&& mins
<= printer
->info_2
->untiltime
)
5569 free_a_printer(&printer
, 2);
5577 /****************************************************************************
5578 Fill in the servername sent in the _spoolss_open_printer_ex() call
5579 ****************************************************************************/
5581 char* get_server_name( Printer_entry
*printer
)
5583 return printer
->servername
;