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 3 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, see <http://www.gnu.org/licenses/>.
24 static TDB_CONTEXT *tdb_forms; /* used for forms files */
25 static TDB_CONTEXT *tdb_drivers; /* used for driver files */
26 static TDB_CONTEXT *tdb_printers; /* used for printers files */
28 #define FORMS_PREFIX "FORMS/"
29 #define DRIVERS_PREFIX "DRIVERS/"
30 #define DRIVER_INIT_PREFIX "DRIVER_INIT/"
31 #define PRINTERS_PREFIX "PRINTERS/"
32 #define SECDESC_PREFIX "SECDESC/"
33 #define GLOBAL_C_SETPRINTER "GLOBALS/c_setprinter"
35 #define NTDRIVERS_DATABASE_VERSION_1 1
36 #define NTDRIVERS_DATABASE_VERSION_2 2
37 #define NTDRIVERS_DATABASE_VERSION_3 3 /* little endian version of v2 */
38 #define NTDRIVERS_DATABASE_VERSION_4 4 /* fix generic bits in security descriptors */
39 #define NTDRIVERS_DATABASE_VERSION_5 5 /* normalize keys in ntprinters.tdb */
41 /* Map generic permissions to printer object specific permissions */
43 const struct generic_mapping printer_generic_mapping = {
50 const struct standard_mapping printer_std_mapping = {
57 /* Map generic permissions to print server object specific permissions */
59 const struct generic_mapping printserver_generic_mapping = {
66 const struct generic_mapping printserver_std_mapping = {
73 /* Map generic permissions to job object specific permissions */
75 const struct generic_mapping job_generic_mapping = {
82 /* We need one default form to support our default printer. Msoft adds the
83 forms it wants and in the ORDER it wants them (note: DEVMODE papersize is an
84 array index). Letter is always first, so (for the current code) additions
85 always put things in the correct order. */
86 static const nt_forms_struct default_forms[] = {
87 {"Letter",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
88 {"Letter Small",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
89 {"Tabloid",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
90 {"Ledger",0x1,0x696b8,0x44368,0x0,0x0,0x696b8,0x44368},
91 {"Legal",0x1,0x34b5c,0x56d10,0x0,0x0,0x34b5c,0x56d10},
92 {"Statement",0x1,0x221b4,0x34b5c,0x0,0x0,0x221b4,0x34b5c},
93 {"Executive",0x1,0x2cf56,0x411cc,0x0,0x0,0x2cf56,0x411cc},
94 {"A3",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
95 {"A4",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
96 {"A4 Small",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
97 {"A5",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
98 {"B4 (JIS)",0x1,0x3ebe8,0x58de0,0x0,0x0,0x3ebe8,0x58de0},
99 {"B5 (JIS)",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
100 {"Folio",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
101 {"Quarto",0x1,0x347d8,0x43238,0x0,0x0,0x347d8,0x43238},
102 {"10x14",0x1,0x3e030,0x56d10,0x0,0x0,0x3e030,0x56d10},
103 {"11x17",0x1,0x44368,0x696b8,0x0,0x0,0x44368,0x696b8},
104 {"Note",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
105 {"Envelope #9",0x1,0x18079,0x37091,0x0,0x0,0x18079,0x37091},
106 {"Envelope #10",0x1,0x19947,0x3ae94,0x0,0x0,0x19947,0x3ae94},
107 {"Envelope #11",0x1,0x1be7c,0x40565,0x0,0x0,0x1be7c,0x40565},
108 {"Envelope #12",0x1,0x1d74a,0x44368,0x0,0x0,0x1d74a,0x44368},
109 {"Envelope #14",0x1,0x1f018,0x47504,0x0,0x0,0x1f018,0x47504},
110 {"C size sheet",0x1,0x696b8,0x886d0,0x0,0x0,0x696b8,0x886d0},
111 {"D size sheet",0x1,0x886d0,0xd2d70,0x0,0x0,0x886d0,0xd2d70},
112 {"E size sheet",0x1,0xd2d70,0x110da0,0x0,0x0,0xd2d70,0x110da0},
113 {"Envelope DL",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
114 {"Envelope C5",0x1,0x278d0,0x37e88,0x0,0x0,0x278d0,0x37e88},
115 {"Envelope C3",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
116 {"Envelope C4",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
117 {"Envelope C6",0x1,0x1bd50,0x278d0,0x0,0x0,0x1bd50,0x278d0},
118 {"Envelope C65",0x1,0x1bd50,0x37e88,0x0,0x0,0x1bd50,0x37e88},
119 {"Envelope B4",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
120 {"Envelope B5",0x1,0x2af80,0x3d090,0x0,0x0,0x2af80,0x3d090},
121 {"Envelope B6",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
122 {"Envelope",0x1,0x1adb0,0x38270,0x0,0x0,0x1adb0,0x38270},
123 {"Envelope Monarch",0x1,0x18079,0x2e824,0x0,0x0,0x18079,0x2e824},
124 {"6 3/4 Envelope",0x1,0x167ab,0x284ec,0x0,0x0,0x167ab,0x284ec},
125 {"US Std Fanfold",0x1,0x5c3e1,0x44368,0x0,0x0,0x5c3e1,0x44368},
126 {"German Std Fanfold",0x1,0x34b5c,0x4a6a0,0x0,0x0,0x34b5c,0x4a6a0},
127 {"German Legal Fanfold",0x1,0x34b5c,0x509d8,0x0,0x0,0x34b5c,0x509d8},
128 {"B4 (ISO)",0x1,0x3d090,0x562e8,0x0,0x0,0x3d090,0x562e8},
129 {"Japanese Postcard",0x1,0x186a0,0x24220,0x0,0x0,0x186a0,0x24220},
130 {"9x11",0x1,0x37cf8,0x44368,0x0,0x0,0x37cf8,0x44368},
131 {"10x11",0x1,0x3e030,0x44368,0x0,0x0,0x3e030,0x44368},
132 {"15x11",0x1,0x5d048,0x44368,0x0,0x0,0x5d048,0x44368},
133 {"Envelope Invite",0x1,0x35b60,0x35b60,0x0,0x0,0x35b60,0x35b60},
134 {"Reserved48",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
135 {"Reserved49",0x1,0x1,0x1,0x0,0x0,0x1,0x1},
136 {"Letter Extra",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
137 {"Legal Extra",0x1,0x3ae94,0x5d048,0x0,0x0,0x3ae94,0x5d048},
138 {"Tabloid Extra",0x1,0x4a6a0,0x6f9f0,0x0,0x0,0x4a6a0,0x6f9f0},
139 {"A4 Extra",0x1,0x397c2,0x4eb16,0x0,0x0,0x397c2,0x4eb16},
140 {"Letter Transverse",0x1,0x34b5c,0x44368,0x0,0x0,0x34b5c,0x44368},
141 {"A4 Transverse",0x1,0x33450,0x48828,0x0,0x0,0x33450,0x48828},
142 {"Letter Extra Transverse",0x1,0x3ae94,0x4a6a0,0x0,0x0,0x3ae94,0x4a6a0},
143 {"Super A",0x1,0x376b8,0x56ea0,0x0,0x0,0x376b8,0x56ea0},
144 {"Super B",0x1,0x4a768,0x76e58,0x0,0x0,0x4a768,0x76e58},
145 {"Letter Plus",0x1,0x34b5c,0x4eb16,0x0,0x0,0x34b5c,0x4eb16},
146 {"A4 Plus",0x1,0x33450,0x50910,0x0,0x0,0x33450,0x50910},
147 {"A5 Transverse",0x1,0x24220,0x33450,0x0,0x0,0x24220,0x33450},
148 {"B5 (JIS) Transverse",0x1,0x2c6f0,0x3ebe8,0x0,0x0,0x2c6f0,0x3ebe8},
149 {"A3 Extra",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
150 {"A5 Extra",0x1,0x2a7b0,0x395f8,0x0,0x0,0x2a7b0,0x395f8},
151 {"B5 (ISO) Extra",0x1,0x31128,0x43620,0x0,0x0,0x31128,0x43620},
152 {"A2",0x1,0x668a0,0x91050,0x0,0x0,0x668a0,0x91050},
153 {"A3 Transverse",0x1,0x48828,0x668a0,0x0,0x0,0x48828,0x668a0},
154 {"A3 Extra Transverse",0x1,0x4e9d0,0x6ca48,0x0,0x0,0x4e9d0,0x6ca48},
155 {"Japanese Double Postcard",0x1,0x30d40,0x24220,0x0,0x0,0x30d40,0x24220},
156 {"A6",0x1,0x19a28,0x24220,0x0,0x0,0x19a28,0x24220},
157 {"Japanese Envelope Kaku #2",0x1,0x3a980,0x510e0,0x0,0x0,0x3a980,0x510e0},
158 {"Japanese Envelope Kaku #3",0x1,0x34bc0,0x43a08,0x0,0x0,0x34bc0,0x43a08},
159 {"Japanese Envelope Chou #3",0x1,0x1d4c0,0x395f8,0x0,0x0,0x1d4c0,0x395f8},
160 {"Japanese Envelope Chou #4",0x1,0x15f90,0x320c8,0x0,0x0,0x15f90,0x320c8},
161 {"Letter Rotated",0x1,0x44368,0x34b5c,0x0,0x0,0x44368,0x34b5c},
162 {"A3 Rotated",0x1,0x668a0,0x48828,0x0,0x0,0x668a0,0x48828},
163 {"A4 Rotated",0x1,0x48828,0x33450,0x0,0x0,0x48828,0x33450},
164 {"A5 Rotated",0x1,0x33450,0x24220,0x0,0x0,0x33450,0x24220},
165 {"B4 (JIS) Rotated",0x1,0x58de0,0x3ebe8,0x0,0x0,0x58de0,0x3ebe8},
166 {"B5 (JIS) Rotated",0x1,0x3ebe8,0x2c6f0,0x0,0x0,0x3ebe8,0x2c6f0},
167 {"Japanese Postcard Rotated",0x1,0x24220,0x186a0,0x0,0x0,0x24220,0x186a0},
168 {"Double Japan Postcard Rotated",0x1,0x24220,0x30d40,0x0,0x0,0x24220,0x30d40},
169 {"A6 Rotated",0x1,0x24220,0x19a28,0x0,0x0,0x24220,0x19a28},
170 {"Japan Envelope Kaku #2 Rotated",0x1,0x510e0,0x3a980,0x0,0x0,0x510e0,0x3a980},
171 {"Japan Envelope Kaku #3 Rotated",0x1,0x43a08,0x34bc0,0x0,0x0,0x43a08, 0x34bc0},
172 {"Japan Envelope Chou #3 Rotated",0x1,0x395f8,0x1d4c0,0x0,0x0,0x395f8,0x1d4c0},
173 {"Japan Envelope Chou #4 Rotated",0x1,0x320c8,0x15f90,0x0,0x0,0x320c8,0x15f90},
174 {"B6 (JIS)",0x1,0x1f400,0x2c6f0,0x0,0x0,0x1f400,0x2c6f0},
175 {"B6 (JIS) Rotated",0x1,0x2c6f0,0x1f400,0x0,0x0,0x2c6f0,0x1f400},
176 {"12x11",0x1,0x4a724,0x443e1,0x0,0x0,0x4a724,0x443e1},
177 {"Japan Envelope You #4",0x1,0x19a28,0x395f8,0x0,0x0,0x19a28,0x395f8},
178 {"Japan Envelope You #4 Rotated",0x1,0x395f8,0x19a28,0x0,0x0,0x395f8,0x19a28},
179 {"PRC 16K",0x1,0x2de60,0x3f7a0,0x0,0x0,0x2de60,0x3f7a0},
180 {"PRC 32K",0x1,0x1fbd0,0x2cec0,0x0,0x0,0x1fbd0,0x2cec0},
181 {"PRC 32K(Big)",0x1,0x222e0,0x318f8,0x0,0x0,0x222e0,0x318f8},
182 {"PRC Envelope #1",0x1,0x18e70,0x28488,0x0,0x0,0x18e70,0x28488},
183 {"PRC Envelope #2",0x1,0x18e70,0x2af80,0x0,0x0,0x18e70,0x2af80},
184 {"PRC Envelope #3",0x1,0x1e848,0x2af80,0x0,0x0,0x1e848,0x2af80},
185 {"PRC Envelope #4",0x1,0x1adb0,0x32c80,0x0,0x0,0x1adb0,0x32c80},
186 {"PRC Envelope #5",0x1,0x1adb0,0x35b60,0x0,0x0,0x1adb0,0x35b60},
187 {"PRC Envelope #6",0x1,0x1d4c0,0x38270,0x0,0x0,0x1d4c0,0x38270},
188 {"PRC Envelope #7",0x1,0x27100,0x38270,0x0,0x0,0x27100,0x38270},
189 {"PRC Envelope #8",0x1,0x1d4c0,0x4b708,0x0,0x0,0x1d4c0,0x4b708},
190 {"PRC Envelope #9",0x1,0x37e88,0x4f1a0,0x0,0x0,0x37e88,0x4f1a0},
191 {"PRC Envelope #10",0x1,0x4f1a0,0x6fd10,0x0,0x0,0x4f1a0,0x6fd10},
192 {"PRC 16K Rotated",0x1,0x3f7a0,0x2de60,0x0,0x0,0x3f7a0,0x2de60},
193 {"PRC 32K Rotated",0x1,0x2cec0,0x1fbd0,0x0,0x0,0x2cec0,0x1fbd0},
194 {"PRC 32K(Big) Rotated",0x1,0x318f8,0x222e0,0x0,0x0,0x318f8,0x222e0},
195 {"PRC Envelope #1 Rotated",0x1,0x28488,0x18e70,0x0,0x0,0x28488,0x18e70},
196 {"PRC Envelope #2 Rotated",0x1,0x2af80,0x18e70,0x0,0x0,0x2af80,0x18e70},
197 {"PRC Envelope #3 Rotated",0x1,0x2af80,0x1e848,0x0,0x0,0x2af80,0x1e848},
198 {"PRC Envelope #4 Rotated",0x1,0x32c80,0x1adb0,0x0,0x0,0x32c80,0x1adb0},
199 {"PRC Envelope #5 Rotated",0x1,0x35b60,0x1adb0,0x0,0x0,0x35b60,0x1adb0},
200 {"PRC Envelope #6 Rotated",0x1,0x38270,0x1d4c0,0x0,0x0,0x38270,0x1d4c0},
201 {"PRC Envelope #7 Rotated",0x1,0x38270,0x27100,0x0,0x0,0x38270,0x27100},
202 {"PRC Envelope #8 Rotated",0x1,0x4b708,0x1d4c0,0x0,0x0,0x4b708,0x1d4c0},
203 {"PRC Envelope #9 Rotated",0x1,0x4f1a0,0x37e88,0x0,0x0,0x4f1a0,0x37e88},
204 {"PRC Envelope #10 Rotated",0x1,0x6fd10,0x4f1a0,0x0,0x0,0x6fd10,0x4f1a0}
208 const char *long_archi;
209 const char *short_archi;
213 #define SPL_ARCH_WIN40 "WIN40"
214 #define SPL_ARCH_W32X86 "W32X86"
215 #define SPL_ARCH_W32MIPS "W32MIPS"
216 #define SPL_ARCH_W32ALPHA "W32ALPHA"
217 #define SPL_ARCH_W32PPC "W32PPC"
218 #define SPL_ARCH_IA64 "IA64"
219 #define SPL_ARCH_X64 "x64"
221 static const struct table_node archi_table[]= {
223 {"Windows 4.0", SPL_ARCH_WIN40, 0 },
224 {"Windows NT x86", SPL_ARCH_W32X86, 2 },
225 {"Windows NT R4000", SPL_ARCH_W32MIPS, 2 },
226 {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA, 2 },
227 {"Windows NT PowerPC", SPL_ARCH_W32PPC, 2 },
228 {"Windows IA64", SPL_ARCH_IA64, 3 },
229 {"Windows x64", SPL_ARCH_X64, 3 },
234 /****************************************************************************
235 generate a new TDB_DATA key for storing a printer
236 ****************************************************************************/
238 static TDB_DATA make_printer_tdbkey(TALLOC_CTX *ctx, const char *sharename )
244 fstrcpy(share, sharename);
247 keystr = talloc_asprintf(ctx, "%s%s", PRINTERS_PREFIX, share);
248 key = string_term_tdb_data(keystr ? keystr : "");
253 /****************************************************************************
254 generate a new TDB_DATA key for storing a printer security descriptor
255 ****************************************************************************/
257 static TDB_DATA make_printers_secdesc_tdbkey(TALLOC_CTX *ctx,
258 const char* sharename )
264 fstrcpy(share, sharename );
267 keystr = talloc_asprintf(ctx, "%s%s", SECDESC_PREFIX, share);
268 key = string_term_tdb_data(keystr ? keystr : "");
273 /****************************************************************************
274 ****************************************************************************/
276 static bool upgrade_to_version_3(void)
278 TDB_DATA kbuf, newkey, dbuf;
280 DEBUG(0,("upgrade_to_version_3: upgrading print tdb's to version 3\n"));
282 for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr;
283 newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
285 dbuf = tdb_fetch(tdb_drivers, kbuf);
287 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
288 DEBUG(0,("upgrade_to_version_3:moving form\n"));
289 if (tdb_store(tdb_forms, kbuf, dbuf, TDB_REPLACE) != 0) {
290 SAFE_FREE(dbuf.dptr);
291 DEBUG(0,("upgrade_to_version_3: failed to move form. Error (%s).\n", tdb_errorstr(tdb_forms)));
294 if (tdb_delete(tdb_drivers, kbuf) != 0) {
295 SAFE_FREE(dbuf.dptr);
296 DEBUG(0,("upgrade_to_version_3: failed to delete form. Error (%s)\n", tdb_errorstr(tdb_drivers)));
301 if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
302 DEBUG(0,("upgrade_to_version_3:moving printer\n"));
303 if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
304 SAFE_FREE(dbuf.dptr);
305 DEBUG(0,("upgrade_to_version_3: failed to move printer. Error (%s)\n", tdb_errorstr(tdb_printers)));
308 if (tdb_delete(tdb_drivers, kbuf) != 0) {
309 SAFE_FREE(dbuf.dptr);
310 DEBUG(0,("upgrade_to_version_3: failed to delete printer. Error (%s)\n", tdb_errorstr(tdb_drivers)));
315 if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
316 DEBUG(0,("upgrade_to_version_3:moving secdesc\n"));
317 if (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) != 0) {
318 SAFE_FREE(dbuf.dptr);
319 DEBUG(0,("upgrade_to_version_3: failed to move secdesc. Error (%s)\n", tdb_errorstr(tdb_printers)));
322 if (tdb_delete(tdb_drivers, kbuf) != 0) {
323 SAFE_FREE(dbuf.dptr);
324 DEBUG(0,("upgrade_to_version_3: failed to delete secdesc. Error (%s)\n", tdb_errorstr(tdb_drivers)));
329 SAFE_FREE(dbuf.dptr);
335 /*******************************************************************
336 Fix an issue with security descriptors. Printer sec_desc must
337 use more than the generic bits that were previously used
338 in <= 3.0.14a. They must also have a owner and group SID assigned.
339 Otherwise, any printers than have been migrated to a Windows
340 host using printmig.exe will not be accessible.
341 *******************************************************************/
343 static int sec_desc_upg_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
344 TDB_DATA data, void *state )
347 SEC_DESC_BUF *sd_orig = NULL;
348 SEC_DESC_BUF *sd_new, *sd_store;
349 SEC_DESC *sec, *new_sec;
350 TALLOC_CTX *ctx = state;
355 if (!data.dptr || data.dsize == 0) {
359 if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) != 0 ) {
363 /* upgrade the security descriptor */
365 status = unmarshall_sec_desc_buf(ctx, data.dptr, data.dsize, &sd_orig);
366 if (!NT_STATUS_IS_OK(status)) {
367 /* delete bad entries */
368 DEBUG(0,("sec_desc_upg_fn: Failed to parse original sec_desc for %si. Deleting....\n",
369 (const char *)key.dptr ));
370 tdb_delete( tdb_printers, key );
379 /* 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 new_sec = make_sec_desc( ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
408 &global_sid_Builtin_Administrators,
409 &global_sid_Builtin_Administrators,
410 NULL, NULL, &size_new_sec );
414 sd_new = make_sec_desc_buf( ctx, size_new_sec, new_sec );
419 if ( !(sd_store = sec_desc_merge( ctx, sd_new, sd_orig )) ) {
420 DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key.dptr ));
426 sd_size = ndr_size_security_descriptor(sd_store->sd, NULL, 0)
427 + sizeof(SEC_DESC_BUF);
429 status = marshall_sec_desc_buf(ctx, sd_store, &data.dptr, &data.dsize);
430 if (!NT_STATUS_IS_OK(status)) {
431 DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key.dptr ));
435 result = tdb_store( tdb_printers, key, data, TDB_REPLACE );
437 /* 0 to continue and non-zero to stop traversal */
439 return (result == -1);
442 /*******************************************************************
443 *******************************************************************/
445 static bool upgrade_to_version_4(void)
450 DEBUG(0,("upgrade_to_version_4: upgrading printer security descriptors\n"));
452 if ( !(ctx = talloc_init( "upgrade_to_version_4" )) )
455 result = tdb_traverse( tdb_printers, sec_desc_upg_fn, ctx );
457 talloc_destroy( ctx );
459 return ( result != -1 );
462 /*******************************************************************
463 Fix an issue with security descriptors. Printer sec_desc must
464 use more than the generic bits that were previously used
465 in <= 3.0.14a. They must also have a owner and group SID assigned.
466 Otherwise, any printers than have been migrated to a Windows
467 host using printmig.exe will not be accessible.
468 *******************************************************************/
470 static int normalize_printers_fn( TDB_CONTEXT *the_tdb, TDB_DATA key,
471 TDB_DATA data, void *state )
473 TALLOC_CTX *ctx = talloc_tos();
476 if (!data.dptr || data.dsize == 0)
479 /* upgrade printer records and security descriptors */
481 if ( strncmp((const char *) key.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX) ) == 0 ) {
482 new_key = make_printer_tdbkey(ctx, (const char *)key.dptr+strlen(PRINTERS_PREFIX) );
484 else if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) == 0 ) {
485 new_key = make_printers_secdesc_tdbkey(ctx, (const char *)key.dptr+strlen(SECDESC_PREFIX) );
488 /* ignore this record */
492 /* delete the original record and store under the normalized key */
494 if ( tdb_delete( the_tdb, key ) != 0 ) {
495 DEBUG(0,("normalize_printers_fn: tdb_delete for [%s] failed!\n",
500 if ( tdb_store( the_tdb, new_key, data, TDB_REPLACE) != 0 ) {
501 DEBUG(0,("normalize_printers_fn: failed to store new record for [%s]!\n",
509 /*******************************************************************
510 *******************************************************************/
512 static bool upgrade_to_version_5(void)
517 DEBUG(0,("upgrade_to_version_5: normalizing printer keys\n"));
519 if ( !(ctx = talloc_init( "upgrade_to_version_5" )) )
522 result = tdb_traverse( tdb_printers, normalize_printers_fn, NULL );
524 talloc_destroy( ctx );
526 return ( result != -1 );
529 /****************************************************************************
530 Open the NT printing tdbs. Done once before fork().
531 ****************************************************************************/
533 bool nt_printing_init(struct messaging_context *msg_ctx)
535 const char *vstring = "INFO/version";
539 if ( tdb_drivers && tdb_printers && tdb_forms )
543 tdb_close(tdb_drivers);
544 tdb_drivers = tdb_open_log(state_path("ntdrivers.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
546 DEBUG(0,("nt_printing_init: Failed to open nt drivers database %s (%s)\n",
547 state_path("ntdrivers.tdb"), strerror(errno) ));
552 tdb_close(tdb_printers);
553 tdb_printers = tdb_open_log(state_path("ntprinters.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
555 DEBUG(0,("nt_printing_init: Failed to open nt printers database %s (%s)\n",
556 state_path("ntprinters.tdb"), strerror(errno) ));
561 tdb_close(tdb_forms);
562 tdb_forms = tdb_open_log(state_path("ntforms.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
564 DEBUG(0,("nt_printing_init: Failed to open nt forms database %s (%s)\n",
565 state_path("ntforms.tdb"), strerror(errno) ));
569 /* handle a Samba upgrade */
571 vers_id = tdb_fetch_int32(tdb_drivers, vstring);
573 DEBUG(10, ("Fresh database\n"));
574 tdb_store_int32( tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5 );
575 vers_id = NTDRIVERS_DATABASE_VERSION_5;
578 if ( vers_id != NTDRIVERS_DATABASE_VERSION_5 ) {
580 if ((vers_id == NTDRIVERS_DATABASE_VERSION_1) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_1)) {
581 if (!upgrade_to_version_3())
583 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3);
584 vers_id = NTDRIVERS_DATABASE_VERSION_3;
587 if ((vers_id == NTDRIVERS_DATABASE_VERSION_2) || (IREV(vers_id) == NTDRIVERS_DATABASE_VERSION_2)) {
588 /* Written on a bigendian machine with old fetch_int code. Save as le. */
589 /* The only upgrade between V2 and V3 is to save the version in little-endian. */
590 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_3);
591 vers_id = NTDRIVERS_DATABASE_VERSION_3;
594 if (vers_id == NTDRIVERS_DATABASE_VERSION_3 ) {
595 if ( !upgrade_to_version_4() )
597 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_4);
598 vers_id = NTDRIVERS_DATABASE_VERSION_4;
601 if (vers_id == NTDRIVERS_DATABASE_VERSION_4 ) {
602 if ( !upgrade_to_version_5() )
604 tdb_store_int32(tdb_drivers, vstring, NTDRIVERS_DATABASE_VERSION_5);
605 vers_id = NTDRIVERS_DATABASE_VERSION_5;
609 if ( vers_id != NTDRIVERS_DATABASE_VERSION_5 ) {
610 DEBUG(0,("nt_printing_init: Unknown printer database version [%d]\n", vers_id));
615 update_c_setprinter(True);
618 * register callback to handle updating printers as new
619 * drivers are installed
622 messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE,
623 do_drv_upgrade_printer);
626 * register callback to handle updating printer data
627 * when a driver is initialized
630 messaging_register(msg_ctx, NULL, MSG_PRINTERDATA_INIT_RESET,
631 reset_all_printerdata);
633 /* of course, none of the message callbacks matter if you don't
634 tell messages.c that you interested in receiving PRINT_GENERAL
635 msgs. This is done in claim_connection() */
638 if ( lp_security() == SEC_ADS ) {
639 win_rc = check_published_printers();
640 if (!W_ERROR_IS_OK(win_rc))
641 DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", win_errstr(win_rc)));
647 /*******************************************************************
648 Function to allow filename parsing "the old way".
649 ********************************************************************/
651 static char *driver_unix_convert(connection_struct *conn,
652 const char *old_name,
653 SMB_STRUCT_STAT *pst)
655 TALLOC_CTX *ctx = talloc_tos();
656 char *name = talloc_strdup(ctx, old_name);
657 char *new_name = NULL;
663 name = unix_clean_name(ctx, name);
667 trim_string(name,"/","/");
668 unix_convert(ctx,conn, name, false, &new_name, NULL, pst);
672 /*******************************************************************
673 tdb traversal function for counting printers.
674 ********************************************************************/
676 static int traverse_counting_printers(TDB_CONTEXT *t, TDB_DATA key,
677 TDB_DATA data, void *context)
679 int *printer_count = (int*)context;
681 if (memcmp(PRINTERS_PREFIX, key.dptr, sizeof(PRINTERS_PREFIX)-1) == 0) {
683 DEBUG(10,("traverse_counting_printers: printer = [%s] printer_count = %d\n", key.dptr, *printer_count));
689 /*******************************************************************
690 Update the spooler global c_setprinter. This variable is initialized
691 when the parent smbd starts with the number of existing printers. It
692 is monotonically increased by the current number of printers *after*
693 each add or delete printer RPC. Only Microsoft knows why... JRR020119
694 ********************************************************************/
696 uint32 update_c_setprinter(bool initialize)
699 int32 printer_count = 0;
701 tdb_lock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
703 /* Traverse the tdb, counting the printers */
704 tdb_traverse(tdb_printers, traverse_counting_printers, (void *)&printer_count);
706 /* If initializing, set c_setprinter to current printers count
707 * otherwise, bump it by the current printer count
710 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER) + printer_count;
712 c_setprinter = printer_count;
714 DEBUG(10,("update_c_setprinter: c_setprinter = %u\n", (unsigned int)c_setprinter));
715 tdb_store_int32(tdb_printers, GLOBAL_C_SETPRINTER, c_setprinter);
717 tdb_unlock_bystring(tdb_printers, GLOBAL_C_SETPRINTER);
719 return (uint32)c_setprinter;
722 /*******************************************************************
723 Get the spooler global c_setprinter, accounting for initialization.
724 ********************************************************************/
726 uint32 get_c_setprinter(void)
728 int32 c_setprinter = tdb_fetch_int32(tdb_printers, GLOBAL_C_SETPRINTER);
730 if (c_setprinter == (int32)-1)
731 c_setprinter = update_c_setprinter(True);
733 DEBUG(10,("get_c_setprinter: c_setprinter = %d\n", c_setprinter));
735 return (uint32)c_setprinter;
738 /****************************************************************************
739 Get builtin form struct list.
740 ****************************************************************************/
742 int get_builtin_ntforms(nt_forms_struct **list)
744 *list = (nt_forms_struct *)memdup(&default_forms[0], sizeof(default_forms));
748 return sizeof(default_forms) / sizeof(default_forms[0]);
751 /****************************************************************************
752 get a builtin form struct
753 ****************************************************************************/
755 bool get_a_builtin_ntform_by_string(const char *form_name, nt_forms_struct *form)
758 DEBUGADD(6,("Looking for builtin form %s \n", form_name));
759 count = sizeof(default_forms) / sizeof(default_forms[0]);
760 for (i=0;i<count;i++) {
761 if (strequal(form_name,default_forms[i].name)) {
762 DEBUGADD(6,("Found builtin form %s \n", form_name));
763 memcpy(form,&default_forms[i],sizeof(*form));
771 /****************************************************************************
772 get a form struct list.
773 ****************************************************************************/
775 int get_ntforms(nt_forms_struct **list)
777 TDB_DATA kbuf, newkey, dbuf;
778 nt_forms_struct form;
785 for (kbuf = tdb_firstkey(tdb_forms);
787 newkey = tdb_nextkey(tdb_forms, kbuf), free(kbuf.dptr), kbuf=newkey)
789 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0)
792 dbuf = tdb_fetch(tdb_forms, kbuf);
796 fstrcpy(form.name, (const char *)kbuf.dptr+strlen(FORMS_PREFIX));
797 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddddddd",
798 &i, &form.flag, &form.width, &form.length, &form.left,
799 &form.top, &form.right, &form.bottom);
800 SAFE_FREE(dbuf.dptr);
801 if (ret != dbuf.dsize)
804 *list = SMB_REALLOC_ARRAY(*list, nt_forms_struct, n+1);
806 DEBUG(0,("get_ntforms: Realloc fail.\n"));
817 /****************************************************************************
818 write a form struct list
819 ****************************************************************************/
821 int write_ntforms(nt_forms_struct **list, int number)
823 TALLOC_CTX *ctx = talloc_tos();
830 for (i=0;i<number;i++) {
831 /* save index, so list is rebuilt in correct order */
832 len = tdb_pack(NULL, 0, "dddddddd",
833 i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
834 (*list)[i].left, (*list)[i].top, (*list)[i].right,
839 buf = TALLOC_ARRAY(ctx, char, len);
843 len = tdb_pack((uint8 *)buf, len, "dddddddd",
844 i, (*list)[i].flag, (*list)[i].width, (*list)[i].length,
845 (*list)[i].left, (*list)[i].top, (*list)[i].right,
847 key = talloc_asprintf(ctx, "%s%s", FORMS_PREFIX, (*list)[i].name);
852 dbuf.dptr = (uint8 *)buf;
853 if (tdb_store_bystring(tdb_forms, key, dbuf, TDB_REPLACE) != 0) {
865 /****************************************************************************
866 add a form struct at the end of the list
867 ****************************************************************************/
868 bool add_a_form(nt_forms_struct **list, struct spoolss_AddFormInfo1 *form, int *count)
874 * NT tries to add forms even when
875 * they are already in the base
876 * only update the values if already present
881 for (n=0; n<*count; n++) {
882 if ( strequal((*list)[n].name, form->form_name) ) {
889 if((*list=SMB_REALLOC_ARRAY(*list, nt_forms_struct, n+1)) == NULL) {
890 DEBUG(0,("add_a_form: failed to enlarge forms list!\n"));
893 fstrcpy((*list)[n].name, form->form_name);
897 (*list)[n].flag = form->flags;
898 (*list)[n].width = form->size.width;
899 (*list)[n].length = form->size.height;
900 (*list)[n].left = form->area.left;
901 (*list)[n].top = form->area.top;
902 (*list)[n].right = form->area.right;
903 (*list)[n].bottom = form->area.bottom;
905 DEBUG(6,("add_a_form: Successfully %s form [%s]\n",
906 update ? "updated" : "added", form->form_name));
911 /****************************************************************************
912 Delete a named form struct.
913 ****************************************************************************/
915 bool delete_a_form(nt_forms_struct **list, const char *del_name, int *count, WERROR *ret)
922 for (n=0; n<*count; n++) {
923 if (!strncmp((*list)[n].name, del_name, strlen(del_name))) {
924 DEBUG(103, ("delete_a_form, [%s] in list\n", del_name));
930 DEBUG(10,("delete_a_form, [%s] not found\n", del_name));
931 *ret = WERR_INVALID_PARAM;
935 if (asprintf(&key, "%s%s", FORMS_PREFIX, (*list)[n].name) < 0) {
939 if (tdb_delete_bystring(tdb_forms, key) != 0) {
948 /****************************************************************************
949 Update a form struct.
950 ****************************************************************************/
952 void update_a_form(nt_forms_struct **list, struct spoolss_AddFormInfo1 *form, int count)
956 DEBUG(106, ("[%s]\n", form->form_name));
957 for (n=0; n<count; n++) {
958 DEBUGADD(106, ("n [%d]:[%s]\n", n, (*list)[n].name));
959 if (!strncmp((*list)[n].name, form->form_name, strlen(form->form_name)))
963 if (n==count) return;
965 (*list)[n].flag = form->flags;
966 (*list)[n].width = form->size.width;
967 (*list)[n].length = form->size.height;
968 (*list)[n].left = form->area.left;
969 (*list)[n].top = form->area.top;
970 (*list)[n].right = form->area.right;
971 (*list)[n].bottom = form->area.bottom;
974 /****************************************************************************
975 Get the nt drivers list.
976 Traverse the database and look-up the matching names.
977 ****************************************************************************/
978 int get_ntdrivers(fstring **list, const char *architecture, uint32 version)
981 const char *short_archi;
983 TDB_DATA kbuf, newkey;
985 short_archi = get_short_archi(architecture);
990 if (asprintf(&key, "%s%s/%d/", DRIVERS_PREFIX,
991 short_archi, version) < 0) {
995 for (kbuf = tdb_firstkey(tdb_drivers);
997 newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
999 if (strncmp((const char *)kbuf.dptr, key, strlen(key)) != 0)
1002 if((*list = SMB_REALLOC_ARRAY(*list, fstring, total+1)) == NULL) {
1003 DEBUG(0,("get_ntdrivers: failed to enlarge list!\n"));
1008 fstrcpy((*list)[total], (const char *)kbuf.dptr+strlen(key));
1016 /****************************************************************************
1017 Function to do the mapping between the long architecture name and
1019 ****************************************************************************/
1021 const char *get_short_archi(const char *long_archi)
1025 DEBUG(107,("Getting architecture dependant directory\n"));
1028 } while ( (archi_table[i].long_archi!=NULL ) &&
1029 StrCaseCmp(long_archi, archi_table[i].long_archi) );
1031 if (archi_table[i].long_archi==NULL) {
1032 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
1036 /* this might be client code - but shouldn't this be an fstrcpy etc? */
1038 DEBUGADD(108,("index: [%d]\n", i));
1039 DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
1040 DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
1042 return archi_table[i].short_archi;
1045 /****************************************************************************
1046 Version information in Microsoft files is held in a VS_VERSION_INFO structure.
1047 There are two case to be covered here: PE (Portable Executable) and NE (New
1048 Executable) files. Both files support the same INFO structure, but PE files
1049 store the signature in unicode, and NE files store it as !unicode.
1050 returns -1 on error, 1 on version info found, and 0 on no version info found.
1051 ****************************************************************************/
1053 static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32 *minor)
1059 if ((buf=(char *)SMB_MALLOC(DOS_HEADER_SIZE)) == NULL) {
1060 DEBUG(0,("get_file_version: PE file [%s] DOS Header malloc failed bytes = %d\n",
1061 fname, DOS_HEADER_SIZE));
1065 if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
1066 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %lu\n",
1067 fname, (unsigned long)byte_count));
1068 goto no_version_info;
1071 /* Is this really a DOS header? */
1072 if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
1073 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
1074 fname, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
1075 goto no_version_info;
1078 /* Skip OEM header (if any) and the DOS stub to start of Windows header */
1079 if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
1080 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
1082 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1083 goto no_version_info;
1086 /* Note: DOS_HEADER_SIZE and NE_HEADER_SIZE are incidentally same */
1087 if ((byte_count = vfs_read_data(fsp, buf, NE_HEADER_SIZE)) < NE_HEADER_SIZE) {
1088 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %lu\n",
1089 fname, (unsigned long)byte_count));
1090 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1091 goto no_version_info;
1094 /* The header may be a PE (Portable Executable) or an NE (New Executable) */
1095 if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
1096 unsigned int num_sections;
1097 unsigned int section_table_bytes;
1099 /* Just skip over optional header to get to section table */
1100 if (SMB_VFS_LSEEK(fsp,
1101 SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)-(NE_HEADER_SIZE-PE_HEADER_SIZE),
1102 SEEK_CUR) == (SMB_OFF_T)-1) {
1103 DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
1108 /* get the section table */
1109 num_sections = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS);
1110 section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE;
1111 if (section_table_bytes == 0)
1115 if ((buf=(char *)SMB_MALLOC(section_table_bytes)) == NULL) {
1116 DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
1117 fname, section_table_bytes));
1121 if ((byte_count = vfs_read_data(fsp, buf, section_table_bytes)) < section_table_bytes) {
1122 DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %lu\n",
1123 fname, (unsigned long)byte_count));
1127 /* Iterate the section table looking for the resource section ".rsrc" */
1128 for (i = 0; i < num_sections; i++) {
1129 int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE;
1131 if (strcmp(".rsrc", &buf[sec_offset+PE_HEADER_SECT_NAME_OFFSET]) == 0) {
1132 unsigned int section_pos = IVAL(buf,sec_offset+PE_HEADER_SECT_PTR_DATA_OFFSET);
1133 unsigned int section_bytes = IVAL(buf,sec_offset+PE_HEADER_SECT_SIZE_DATA_OFFSET);
1135 if (section_bytes == 0)
1139 if ((buf=(char *)SMB_MALLOC(section_bytes)) == NULL) {
1140 DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
1141 fname, section_bytes));
1145 /* Seek to the start of the .rsrc section info */
1146 if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
1147 DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
1152 if ((byte_count = vfs_read_data(fsp, buf, section_bytes)) < section_bytes) {
1153 DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %lu\n",
1154 fname, (unsigned long)byte_count));
1158 if (section_bytes < VS_VERSION_INFO_UNICODE_SIZE)
1161 for (i=0; i<section_bytes-VS_VERSION_INFO_UNICODE_SIZE; i++) {
1162 /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
1163 if (buf[i] == 'V' && buf[i+1] == '\0' && buf[i+2] == 'S') {
1164 /* Align to next long address */
1165 int pos = (i + sizeof(VS_SIGNATURE)*2 + 3) & 0xfffffffc;
1167 if (IVAL(buf,pos) == VS_MAGIC_VALUE) {
1168 *major = IVAL(buf,pos+VS_MAJOR_OFFSET);
1169 *minor = IVAL(buf,pos+VS_MINOR_OFFSET);
1171 DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1172 fname, *major, *minor,
1173 (*major>>16)&0xffff, *major&0xffff,
1174 (*minor>>16)&0xffff, *minor&0xffff));
1183 /* Version info not found, fall back to origin date/time */
1184 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname));
1188 } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
1189 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) {
1190 DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
1191 fname, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
1192 /* At this point, we assume the file is in error. It still could be somthing
1193 * else besides a NE file, but it unlikely at this point. */
1197 /* Allocate a bit more space to speed up things */
1199 if ((buf=(char *)SMB_MALLOC(VS_NE_BUF_SIZE)) == NULL) {
1200 DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes = %d\n",
1201 fname, PE_HEADER_SIZE));
1205 /* This is a HACK! I got tired of trying to sort through the messy
1206 * 'NE' file format. If anyone wants to clean this up please have at
1207 * it, but this works. 'NE' files will eventually fade away. JRR */
1208 while((byte_count = vfs_read_data(fsp, buf, VS_NE_BUF_SIZE)) > 0) {
1209 /* Cover case that should not occur in a well formed 'NE' .dll file */
1210 if (byte_count-VS_VERSION_INFO_SIZE <= 0) break;
1212 for(i=0; i<byte_count; i++) {
1213 /* Fast skip past data that can't possibly match */
1214 if (buf[i] != 'V') continue;
1216 /* Potential match data crosses buf boundry, move it to beginning
1217 * of buf, and fill the buf with as much as it will hold. */
1218 if (i>byte_count-VS_VERSION_INFO_SIZE) {
1221 memcpy(buf, &buf[i], byte_count-i);
1222 if ((bc = vfs_read_data(fsp, &buf[byte_count-i], VS_NE_BUF_SIZE-
1223 (byte_count-i))) < 0) {
1225 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
1230 byte_count = bc + (byte_count - i);
1231 if (byte_count<VS_VERSION_INFO_SIZE) break;
1236 /* Check that the full signature string and the magic number that
1237 * follows exist (not a perfect solution, but the chances that this
1238 * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
1239 * twice, as it is simpler to read the code. */
1240 if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
1241 /* Compute skip alignment to next long address */
1242 int skip = -(SMB_VFS_LSEEK(fsp, 0, SEEK_CUR) - (byte_count - i) +
1243 sizeof(VS_SIGNATURE)) & 3;
1244 if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
1246 *major = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MAJOR_OFFSET);
1247 *minor = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MINOR_OFFSET);
1248 DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
1249 fname, *major, *minor,
1250 (*major>>16)&0xffff, *major&0xffff,
1251 (*minor>>16)&0xffff, *minor&0xffff));
1258 /* Version info not found, fall back to origin date/time */
1259 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname));
1264 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
1265 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
1266 fname, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
1277 /****************************************************************************
1278 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
1279 share one or more files. During the MS installation process files are checked
1280 to insure that only a newer version of a shared file is installed over an
1281 older version. There are several possibilities for this comparison. If there
1282 is no previous version, the new one is newer (obviously). If either file is
1283 missing the version info structure, compare the creation date (on Unix use
1284 the modification date). Otherwise chose the numerically larger version number.
1285 ****************************************************************************/
1287 static int file_version_is_newer(connection_struct *conn, fstring new_file, fstring old_file)
1289 bool use_version = true;
1290 char *filepath = NULL;
1294 time_t new_create_time;
1298 time_t old_create_time;
1300 files_struct *fsp = NULL;
1302 SMB_STRUCT_STAT stat_buf;
1306 SET_STAT_INVALID(st);
1307 SET_STAT_INVALID(stat_buf);
1308 new_create_time = (time_t)0;
1309 old_create_time = (time_t)0;
1311 /* Get file version info (if available) for previous file (if it exists) */
1312 filepath = driver_unix_convert(conn,old_file,&stat_buf);
1317 status = SMB_VFS_CREATE_FILE(
1320 0, /* root_dir_fid */
1321 filepath, /* fname */
1322 0, /* create_file_flags */
1323 FILE_GENERIC_READ, /* access_mask */
1324 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1325 FILE_OPEN, /* create_disposition*/
1326 0, /* create_options */
1327 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
1328 INTERNAL_OPEN_ONLY, /* oplock_request */
1329 0, /* allocation_size */
1334 &stat_buf); /* psbuf */
1336 if (!NT_STATUS_IS_OK(status)) {
1337 /* Old file not found, so by definition new file is in fact newer */
1338 DEBUG(10,("file_version_is_newer: Can't open old file [%s], errno = %d\n",
1343 int ret = get_file_version(fsp, old_file, &old_major, &old_minor);
1349 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1351 use_version = false;
1352 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
1355 old_create_time = st.st_mtime;
1356 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n",
1357 (long)old_create_time));
1360 close_file(NULL, fsp, NORMAL_CLOSE);
1363 /* Get file version info (if available) for new file */
1364 filepath = driver_unix_convert(conn,new_file,&stat_buf);
1369 status = SMB_VFS_CREATE_FILE(
1372 0, /* root_dir_fid */
1373 filepath, /* fname */
1374 0, /* create_file_flags */
1375 FILE_GENERIC_READ, /* access_mask */
1376 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1377 FILE_OPEN, /* create_disposition*/
1378 0, /* create_options */
1379 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
1380 INTERNAL_OPEN_ONLY, /* oplock_request */
1381 0, /* allocation_size */
1386 &stat_buf); /* psbuf */
1388 if (!NT_STATUS_IS_OK(status)) {
1389 /* New file not found, this shouldn't occur if the caller did its job */
1390 DEBUG(3,("file_version_is_newer: Can't open new file [%s], errno = %d\n",
1395 int ret = get_file_version(fsp, new_file, &new_major, &new_minor);
1401 DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
1403 use_version = false;
1404 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
1407 new_create_time = st.st_mtime;
1408 DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n",
1409 (long)new_create_time));
1412 close_file(NULL, fsp, NORMAL_CLOSE);
1415 if (use_version && (new_major != old_major || new_minor != old_minor)) {
1416 /* Compare versions and choose the larger version number */
1417 if (new_major > old_major ||
1418 (new_major == old_major && new_minor > old_minor)) {
1420 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1424 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1429 /* Compare modification time/dates and choose the newest time/date */
1430 if (new_create_time > old_create_time) {
1431 DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
1435 DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
1442 close_file(NULL, fsp, NORMAL_CLOSE);
1446 /****************************************************************************
1447 Determine the correct cVersion associated with an architecture and driver
1448 ****************************************************************************/
1449 static uint32 get_correct_cversion(struct pipes_struct *p,
1450 const char *architecture,
1451 fstring driverpath_in,
1456 char *driverpath = NULL;
1457 files_struct *fsp = NULL;
1459 connection_struct *conn = NULL;
1462 fstring printdollar;
1463 int printdollar_snum;
1465 SET_STAT_INVALID(st);
1467 *perr = WERR_INVALID_PARAM;
1469 /* If architecture is Windows 95/98/ME, the version is always 0. */
1470 if (strcmp(architecture, SPL_ARCH_WIN40) == 0) {
1471 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
1476 /* If architecture is Windows x64, the version is always 3. */
1477 if (strcmp(architecture, SPL_ARCH_X64) == 0) {
1478 DEBUG(10,("get_correct_cversion: Driver is x64, cversion = 3\n"));
1483 fstrcpy(printdollar, "print$");
1485 printdollar_snum = find_service(printdollar);
1486 if (printdollar_snum == -1) {
1487 *perr = WERR_NO_SUCH_SHARE;
1491 nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1492 lp_pathname(printdollar_snum),
1493 p->server_info, &oldcwd);
1494 if (!NT_STATUS_IS_OK(nt_status)) {
1495 DEBUG(0,("get_correct_cversion: create_conn_struct "
1496 "returned %s\n", nt_errstr(nt_status)));
1497 *perr = ntstatus_to_werror(nt_status);
1501 /* Open the driver file (Portable Executable format) and determine the
1502 * deriver the cversion. */
1503 driverpath = talloc_asprintf(talloc_tos(),
1512 driverpath = driver_unix_convert(conn,driverpath,&st);
1518 if (!vfs_file_exist(conn, driverpath, &st)) {
1519 *perr = WERR_BADFILE;
1523 status = SMB_VFS_CREATE_FILE(
1526 0, /* root_dir_fid */
1527 driverpath, /* fname */
1528 0, /* create_file_flags */
1529 FILE_GENERIC_READ, /* access_mask */
1530 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1531 FILE_OPEN, /* create_disposition*/
1532 0, /* create_options */
1533 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
1534 INTERNAL_OPEN_ONLY, /* oplock_request */
1535 0, /* allocation_size */
1542 if (!NT_STATUS_IS_OK(status)) {
1543 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = %d\n",
1544 driverpath, errno));
1545 *perr = WERR_ACCESS_DENIED;
1550 int ret = get_file_version(fsp, driverpath, &major, &minor);
1551 if (ret == -1) goto error_exit;
1554 DEBUG(6,("get_correct_cversion: Version info not found [%s]\n", driverpath));
1559 * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
1560 * for more details. Version in this case is not just the version of the
1561 * file, but the version in the sense of kernal mode (2) vs. user mode
1562 * (3) drivers. Other bits of the version fields are the version info.
1565 cversion = major & 0x0000ffff;
1567 case 2: /* WinNT drivers */
1568 case 3: /* Win2K drivers */
1572 DEBUG(6,("get_correct_cversion: cversion invalid [%s] cversion = %d\n",
1573 driverpath, cversion));
1577 DEBUG(10,("get_correct_cversion: Version info found [%s] major = 0x%x minor = 0x%x\n",
1578 driverpath, major, minor));
1581 DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
1582 driverpath, cversion));
1590 close_file(NULL, fsp, NORMAL_CLOSE);
1593 vfs_ChDir(conn, oldcwd);
1594 conn_free_internal(conn);
1596 if (cversion != -1) {
1602 /****************************************************************************
1603 ****************************************************************************/
1604 static WERROR clean_up_driver_struct_level_3(struct pipes_struct *rpc_pipe,
1605 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
1607 const char *architecture;
1613 /* clean up the driver name.
1614 * we can get .\driver.dll
1615 * or worse c:\windows\system\driver.dll !
1617 /* using an intermediate string to not have overlaping memcpy()'s */
1618 if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1619 fstrcpy(new_name, p+1);
1620 fstrcpy(driver->driverpath, new_name);
1623 if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1624 fstrcpy(new_name, p+1);
1625 fstrcpy(driver->datafile, new_name);
1628 if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1629 fstrcpy(new_name, p+1);
1630 fstrcpy(driver->configfile, new_name);
1633 if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1634 fstrcpy(new_name, p+1);
1635 fstrcpy(driver->helpfile, new_name);
1638 if (driver->dependentfiles) {
1639 for (i=0; *driver->dependentfiles[i]; i++) {
1640 if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1641 fstrcpy(new_name, p+1);
1642 fstrcpy(driver->dependentfiles[i], new_name);
1647 architecture = get_short_archi(driver->environment);
1648 if (!architecture) {
1649 return WERR_UNKNOWN_PRINTER_DRIVER;
1652 /* jfm:7/16/2000 the client always sends the cversion=0.
1653 * The server should check which version the driver is by reading
1654 * the PE header of driver->driverpath.
1656 * For Windows 95/98 the version is 0 (so the value sent is correct)
1657 * For Windows NT (the architecture doesn't matter)
1658 * NT 3.1: cversion=0
1659 * NT 3.5/3.51: cversion=1
1663 if ((driver->cversion = get_correct_cversion(rpc_pipe, architecture,
1671 /****************************************************************************
1672 ****************************************************************************/
1673 static WERROR clean_up_driver_struct_level_6(struct pipes_struct *rpc_pipe,
1674 NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
1676 const char *architecture;
1682 /* clean up the driver name.
1683 * we can get .\driver.dll
1684 * or worse c:\windows\system\driver.dll !
1686 /* using an intermediate string to not have overlaping memcpy()'s */
1687 if ((p = strrchr(driver->driverpath,'\\')) != NULL) {
1688 fstrcpy(new_name, p+1);
1689 fstrcpy(driver->driverpath, new_name);
1692 if ((p = strrchr(driver->datafile,'\\')) != NULL) {
1693 fstrcpy(new_name, p+1);
1694 fstrcpy(driver->datafile, new_name);
1697 if ((p = strrchr(driver->configfile,'\\')) != NULL) {
1698 fstrcpy(new_name, p+1);
1699 fstrcpy(driver->configfile, new_name);
1702 if ((p = strrchr(driver->helpfile,'\\')) != NULL) {
1703 fstrcpy(new_name, p+1);
1704 fstrcpy(driver->helpfile, new_name);
1707 if (driver->dependentfiles) {
1708 for (i=0; *driver->dependentfiles[i]; i++) {
1709 if ((p = strrchr(driver->dependentfiles[i],'\\')) != NULL) {
1710 fstrcpy(new_name, p+1);
1711 fstrcpy(driver->dependentfiles[i], new_name);
1716 architecture = get_short_archi(driver->environment);
1717 if (!architecture) {
1718 return WERR_UNKNOWN_PRINTER_DRIVER;
1721 /* jfm:7/16/2000 the client always sends the cversion=0.
1722 * The server should check which version the driver is by reading
1723 * the PE header of driver->driverpath.
1725 * For Windows 95/98 the version is 0 (so the value sent is correct)
1726 * For Windows NT (the architecture doesn't matter)
1727 * NT 3.1: cversion=0
1728 * NT 3.5/3.51: cversion=1
1733 if ((driver->version = get_correct_cversion(rpc_pipe, architecture,
1741 /****************************************************************************
1742 ****************************************************************************/
1743 WERROR clean_up_driver_struct(struct pipes_struct *rpc_pipe,
1744 NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1750 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1751 driver=driver_abstract.info_3;
1752 return clean_up_driver_struct_level_3(rpc_pipe,
1757 NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver;
1758 driver=driver_abstract.info_6;
1759 return clean_up_driver_struct_level_6(rpc_pipe,
1763 return WERR_INVALID_PARAM;
1767 /****************************************************************************
1768 This function sucks and should be replaced. JRA.
1769 ****************************************************************************/
1771 static void convert_level_6_to_level3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *dst, NT_PRINTER_DRIVER_INFO_LEVEL_6 *src)
1773 dst->cversion = src->version;
1775 fstrcpy( dst->name, src->name);
1776 fstrcpy( dst->environment, src->environment);
1777 fstrcpy( dst->driverpath, src->driverpath);
1778 fstrcpy( dst->datafile, src->datafile);
1779 fstrcpy( dst->configfile, src->configfile);
1780 fstrcpy( dst->helpfile, src->helpfile);
1781 fstrcpy( dst->monitorname, src->monitorname);
1782 fstrcpy( dst->defaultdatatype, src->defaultdatatype);
1783 dst->dependentfiles = src->dependentfiles;
1786 #if 0 /* Debugging function */
1788 static char* ffmt(unsigned char *c){
1790 static char ffmt_str[17];
1792 for (i=0; i<16; i++) {
1793 if ((c[i] < ' ') || (c[i] > '~'))
1804 /****************************************************************************
1805 ****************************************************************************/
1806 WERROR move_driver_to_download_area(struct pipes_struct *p,
1807 NT_PRINTER_DRIVER_INFO_LEVEL driver_abstract,
1808 uint32 level, WERROR *perr)
1810 NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver;
1811 NT_PRINTER_DRIVER_INFO_LEVEL_3 converted_driver;
1812 const char *architecture;
1813 char *new_dir = NULL;
1814 char *old_name = NULL;
1815 char *new_name = NULL;
1816 connection_struct *conn = NULL;
1820 TALLOC_CTX *ctx = talloc_tos();
1823 fstring printdollar;
1824 int printdollar_snum;
1829 driver=driver_abstract.info_3;
1830 else if (level==6) {
1831 convert_level_6_to_level3(&converted_driver, driver_abstract.info_6);
1832 driver = &converted_driver;
1834 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)level ));
1835 return WERR_UNKNOWN_LEVEL;
1838 architecture = get_short_archi(driver->environment);
1839 if (!architecture) {
1840 return WERR_UNKNOWN_PRINTER_DRIVER;
1843 fstrcpy(printdollar, "print$");
1845 printdollar_snum = find_service(printdollar);
1846 if (printdollar_snum == -1) {
1847 *perr = WERR_NO_SUCH_SHARE;
1848 return WERR_NO_SUCH_SHARE;
1851 nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1852 lp_pathname(printdollar_snum),
1853 p->server_info, &oldcwd);
1854 if (!NT_STATUS_IS_OK(nt_status)) {
1855 DEBUG(0,("move_driver_to_download_area: create_conn_struct "
1856 "returned %s\n", nt_errstr(nt_status)));
1857 *perr = ntstatus_to_werror(nt_status);
1861 DEBUG(5,("Creating first directory\n"));
1862 new_dir = talloc_asprintf(ctx,
1870 new_dir = driver_unix_convert(conn,new_dir,&st);
1876 create_directory(conn, NULL, new_dir);
1878 /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1879 * listed for this driver which has already been moved, skip it (note:
1880 * drivers may list the same file name several times. Then check if the
1881 * file already exists in archi\cversion\, if so, check that the version
1882 * info (or time stamps if version info is unavailable) is newer (or the
1883 * date is later). If it is, move it to archi\cversion\filexxx.yyy.
1884 * Otherwise, delete the file.
1886 * If a file is not moved to archi\cversion\ because of an error, all the
1887 * rest of the 'unmoved' driver files are removed from archi\. If one or
1888 * more of the driver's files was already moved to archi\cversion\, it
1889 * potentially leaves the driver in a partially updated state. Version
1890 * trauma will most likely occur if an client attempts to use any printer
1891 * bound to the driver. Perhaps a rewrite to make sure the moves can be
1892 * done is appropriate... later JRR
1895 DEBUG(5,("Moving files now !\n"));
1897 if (driver->driverpath && strlen(driver->driverpath)) {
1898 new_name = talloc_asprintf(ctx,
1901 driver->driverpath);
1906 old_name = talloc_asprintf(ctx,
1909 driver->driverpath);
1915 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1916 new_name = driver_unix_convert(conn,new_name,&st);
1921 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1922 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1923 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1924 new_name, old_name));
1925 *perr = WERR_ACCESS_DENIED;
1931 if (driver->datafile && strlen(driver->datafile)) {
1932 if (!strequal(driver->datafile, driver->driverpath)) {
1933 new_name = talloc_asprintf(ctx,
1941 old_name = talloc_asprintf(ctx,
1949 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1950 new_name = driver_unix_convert(conn,new_name,&st);
1955 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1956 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1957 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1958 new_name, old_name));
1959 *perr = WERR_ACCESS_DENIED;
1966 if (driver->configfile && strlen(driver->configfile)) {
1967 if (!strequal(driver->configfile, driver->driverpath) &&
1968 !strequal(driver->configfile, driver->datafile)) {
1969 new_name = talloc_asprintf(ctx,
1972 driver->configfile);
1977 old_name = talloc_asprintf(ctx,
1980 driver->configfile);
1985 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
1986 new_name = driver_unix_convert(conn,new_name,&st);
1991 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
1992 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
1993 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
1994 new_name, old_name));
1995 *perr = WERR_ACCESS_DENIED;
2002 if (driver->helpfile && strlen(driver->helpfile)) {
2003 if (!strequal(driver->helpfile, driver->driverpath) &&
2004 !strequal(driver->helpfile, driver->datafile) &&
2005 !strequal(driver->helpfile, driver->configfile)) {
2006 new_name = talloc_asprintf(ctx,
2014 old_name = talloc_asprintf(ctx,
2022 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
2023 new_name = driver_unix_convert(conn,new_name,&st);
2028 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name, OPENX_FILE_EXISTS_TRUNCATE|
2029 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
2030 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
2031 new_name, old_name));
2032 *perr = WERR_ACCESS_DENIED;
2039 if (driver->dependentfiles) {
2040 for (i=0; *driver->dependentfiles[i]; i++) {
2041 if (!strequal(driver->dependentfiles[i], driver->driverpath) &&
2042 !strequal(driver->dependentfiles[i], driver->datafile) &&
2043 !strequal(driver->dependentfiles[i], driver->configfile) &&
2044 !strequal(driver->dependentfiles[i], driver->helpfile)) {
2046 for (j=0; j < i; j++) {
2047 if (strequal(driver->dependentfiles[i], driver->dependentfiles[j])) {
2052 new_name = talloc_asprintf(ctx,
2055 driver->dependentfiles[i]);
2060 old_name = talloc_asprintf(ctx,
2063 driver->dependentfiles[i]);
2068 if (ver != -1 && (ver=file_version_is_newer(conn, new_name, old_name)) > 0) {
2069 new_name = driver_unix_convert(conn,new_name,&st);
2074 if ( !NT_STATUS_IS_OK(copy_file(ctx,conn, new_name, old_name,
2075 OPENX_FILE_EXISTS_TRUNCATE|
2076 OPENX_FILE_CREATE_IF_NOT_EXIST, 0, False))) {
2077 DEBUG(0,("move_driver_to_download_area: Unable to rename [%s] to [%s]\n",
2078 new_name, old_name));
2079 *perr = WERR_ACCESS_DENIED;
2091 vfs_ChDir(conn, oldcwd);
2092 conn_free_internal(conn);
2095 if (W_ERROR_EQUAL(*perr, WERR_OK)) {
2099 return WERR_UNKNOWN_PRINTER_DRIVER;
2104 /****************************************************************************
2105 ****************************************************************************/
2107 static uint32 add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver)
2109 TALLOC_CTX *ctx = talloc_tos();
2111 const char *architecture;
2112 char *directory = NULL;
2119 architecture = get_short_archi(driver->environment);
2120 if (!architecture) {
2124 /* The names are relative. We store them in the form: \print$\arch\version\driver.xxx
2125 * \\server is added in the rpc server layer.
2126 * It does make sense to NOT store the server's name in the printer TDB.
2129 directory = talloc_asprintf(ctx, "\\print$\\%s\\%d\\",
2130 architecture, driver->cversion);
2135 /* .inf files do not always list a file for each of the four standard files.
2136 * Don't prepend a path to a null filename, or client claims:
2137 * "The server on which the printer resides does not have a suitable
2138 * <printer driver name> printer driver installed. Click OK if you
2139 * wish to install the driver on your local machine."
2141 if (strlen(driver->driverpath)) {
2142 fstrcpy(temp_name, driver->driverpath);
2143 slprintf(driver->driverpath, sizeof(driver->driverpath)-1, "%s%s", directory, temp_name);
2146 if (strlen(driver->datafile)) {
2147 fstrcpy(temp_name, driver->datafile);
2148 slprintf(driver->datafile, sizeof(driver->datafile)-1, "%s%s", directory, temp_name);
2151 if (strlen(driver->configfile)) {
2152 fstrcpy(temp_name, driver->configfile);
2153 slprintf(driver->configfile, sizeof(driver->configfile)-1, "%s%s", directory, temp_name);
2156 if (strlen(driver->helpfile)) {
2157 fstrcpy(temp_name, driver->helpfile);
2158 slprintf(driver->helpfile, sizeof(driver->helpfile)-1, "%s%s", directory, temp_name);
2161 if (driver->dependentfiles) {
2162 for (i=0; *driver->dependentfiles[i]; i++) {
2163 fstrcpy(temp_name, driver->dependentfiles[i]);
2164 slprintf(driver->dependentfiles[i], sizeof(driver->dependentfiles[i])-1, "%s%s", directory, temp_name);
2168 key = talloc_asprintf(ctx, "%s%s/%d/%s", DRIVERS_PREFIX,
2169 architecture, driver->cversion, driver->name);
2174 DEBUG(5,("add_a_printer_driver_3: Adding driver with key %s\n", key ));
2181 len += tdb_pack(buf+len, buflen-len, "dffffffff",
2184 driver->environment,
2189 driver->monitorname,
2190 driver->defaultdatatype);
2192 if (driver->dependentfiles) {
2193 for (i=0; *driver->dependentfiles[i]; i++) {
2194 len += tdb_pack(buf+len, buflen-len, "f",
2195 driver->dependentfiles[i]);
2199 if (len != buflen) {
2200 buf = (uint8 *)SMB_REALLOC(buf, len);
2202 DEBUG(0,("add_a_printer_driver_3: failed to enlarge buffer\n!"));
2213 ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
2217 DEBUG(0,("add_a_printer_driver_3: Adding driver with key %s failed.\n", key ));
2223 /****************************************************************************
2224 ****************************************************************************/
2225 static uint32 add_a_printer_driver_6(NT_PRINTER_DRIVER_INFO_LEVEL_6 *driver)
2227 NT_PRINTER_DRIVER_INFO_LEVEL_3 info3;
2230 info3.cversion = driver->version;
2231 fstrcpy(info3.name,driver->name);
2232 fstrcpy(info3.environment,driver->environment);
2233 fstrcpy(info3.driverpath,driver->driverpath);
2234 fstrcpy(info3.datafile,driver->datafile);
2235 fstrcpy(info3.configfile,driver->configfile);
2236 fstrcpy(info3.helpfile,driver->helpfile);
2237 fstrcpy(info3.monitorname,driver->monitorname);
2238 fstrcpy(info3.defaultdatatype,driver->defaultdatatype);
2239 info3.dependentfiles = driver->dependentfiles;
2241 return add_a_printer_driver_3(&info3);
2245 /****************************************************************************
2246 ****************************************************************************/
2247 static WERROR get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, const char *driver, const char *arch)
2249 NT_PRINTER_DRIVER_INFO_LEVEL_3 info;
2253 fstrcpy(info.name, driver);
2254 fstrcpy(info.defaultdatatype, "RAW");
2256 fstrcpy(info.driverpath, "");
2257 fstrcpy(info.datafile, "");
2258 fstrcpy(info.configfile, "");
2259 fstrcpy(info.helpfile, "");
2261 if ((info.dependentfiles= SMB_MALLOC_ARRAY(fstring, 2)) == NULL)
2264 memset(info.dependentfiles, '\0', 2*sizeof(fstring));
2265 fstrcpy(info.dependentfiles[0], "");
2267 *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&info, sizeof(info));
2269 SAFE_FREE(info.dependentfiles);
2276 /****************************************************************************
2277 ****************************************************************************/
2278 static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring drivername, const char *arch, uint32 version)
2280 NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
2282 const char *architecture;
2287 ZERO_STRUCT(driver);
2289 architecture = get_short_archi(arch);
2290 if ( !architecture ) {
2291 return WERR_UNKNOWN_PRINTER_DRIVER;
2294 /* Windows 4.0 (i.e. win9x) should always use a version of 0 */
2296 if ( strcmp( architecture, SPL_ARCH_WIN40 ) == 0 )
2299 DEBUG(8,("get_a_printer_driver_3: [%s%s/%d/%s]\n", DRIVERS_PREFIX, architecture, version, drivername));
2301 if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
2302 architecture, version, drivername) < 0) {
2306 dbuf = tdb_fetch_bystring(tdb_drivers, key);
2309 return WERR_UNKNOWN_PRINTER_DRIVER;
2312 len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
2321 driver.defaultdatatype);
2324 while (len < dbuf.dsize) {
2325 driver.dependentfiles = SMB_REALLOC_ARRAY(driver.dependentfiles, fstring, i+2);
2326 if ( !driver.dependentfiles ) {
2327 DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
2331 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
2332 &driver.dependentfiles[i]);
2336 if ( driver.dependentfiles )
2337 fstrcpy( driver.dependentfiles[i], "" );
2339 SAFE_FREE(dbuf.dptr);
2342 if (len != dbuf.dsize) {
2343 SAFE_FREE(driver.dependentfiles);
2345 return get_a_printer_driver_3_default(info_ptr, drivername, arch);
2348 *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&driver, sizeof(driver));
2350 SAFE_FREE(driver.dependentfiles);
2357 /****************************************************************************
2358 Debugging function, dump at level 6 the struct in the logs.
2359 ****************************************************************************/
2361 static uint32 dump_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
2364 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
2367 DEBUG(20,("Dumping printer driver at level [%d]\n", level));
2373 if (driver.info_3 == NULL)
2376 info3=driver.info_3;
2378 DEBUGADD(20,("version:[%d]\n", info3->cversion));
2379 DEBUGADD(20,("name:[%s]\n", info3->name));
2380 DEBUGADD(20,("environment:[%s]\n", info3->environment));
2381 DEBUGADD(20,("driverpath:[%s]\n", info3->driverpath));
2382 DEBUGADD(20,("datafile:[%s]\n", info3->datafile));
2383 DEBUGADD(20,("configfile:[%s]\n", info3->configfile));
2384 DEBUGADD(20,("helpfile:[%s]\n", info3->helpfile));
2385 DEBUGADD(20,("monitorname:[%s]\n", info3->monitorname));
2386 DEBUGADD(20,("defaultdatatype:[%s]\n", info3->defaultdatatype));
2388 for (i=0; info3->dependentfiles &&
2389 *info3->dependentfiles[i]; i++) {
2390 DEBUGADD(20,("dependentfile:[%s]\n",
2391 info3->dependentfiles[i]));
2398 DEBUGADD(20,("dump_a_printer_driver: Level %u not implemented\n", (unsigned int)level));
2406 /****************************************************************************
2407 ****************************************************************************/
2408 int pack_devicemode(NT_DEVICEMODE *nt_devmode, uint8 *buf, int buflen)
2412 len += tdb_pack(buf+len, buflen-len, "p", nt_devmode);
2417 len += tdb_pack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2418 nt_devmode->devicename,
2419 nt_devmode->formname,
2421 nt_devmode->specversion,
2422 nt_devmode->driverversion,
2424 nt_devmode->driverextra,
2425 nt_devmode->orientation,
2426 nt_devmode->papersize,
2427 nt_devmode->paperlength,
2428 nt_devmode->paperwidth,
2431 nt_devmode->defaultsource,
2432 nt_devmode->printquality,
2435 nt_devmode->yresolution,
2436 nt_devmode->ttoption,
2437 nt_devmode->collate,
2438 nt_devmode->logpixels,
2441 nt_devmode->bitsperpel,
2442 nt_devmode->pelswidth,
2443 nt_devmode->pelsheight,
2444 nt_devmode->displayflags,
2445 nt_devmode->displayfrequency,
2446 nt_devmode->icmmethod,
2447 nt_devmode->icmintent,
2448 nt_devmode->mediatype,
2449 nt_devmode->dithertype,
2450 nt_devmode->reserved1,
2451 nt_devmode->reserved2,
2452 nt_devmode->panningwidth,
2453 nt_devmode->panningheight,
2454 nt_devmode->nt_dev_private);
2456 if (nt_devmode->nt_dev_private) {
2457 len += tdb_pack(buf+len, buflen-len, "B",
2458 nt_devmode->driverextra,
2459 nt_devmode->nt_dev_private);
2462 DEBUG(8,("Packed devicemode [%s]\n", nt_devmode->formname));
2467 /****************************************************************************
2468 Pack all values in all printer keys
2469 ***************************************************************************/
2471 static int pack_values(NT_PRINTER_DATA *data, uint8 *buf, int buflen)
2475 REGISTRY_VALUE *val;
2476 REGVAL_CTR *val_ctr;
2483 /* loop over all keys */
2485 for ( i=0; i<data->num_keys; i++ ) {
2486 val_ctr = data->keys[i].values;
2487 num_values = regval_ctr_numvals( val_ctr );
2489 /* pack the keyname followed by a empty value */
2491 len += tdb_pack(buf+len, buflen-len, "pPdB",
2492 &data->keys[i].name,
2498 /* now loop over all values */
2500 for ( j=0; j<num_values; j++ ) {
2501 /* pathname should be stored as <key>\<value> */
2503 val = regval_ctr_specific_value( val_ctr, j );
2504 if (asprintf(&path, "%s\\%s",
2506 regval_name(val)) < 0) {
2510 len += tdb_pack(buf+len, buflen-len, "pPdB",
2515 regval_data_p(val) );
2517 DEBUG(8,("specific: [%s], len: %d\n", regval_name(val), regval_size(val)));
2525 len += tdb_pack(buf+len, buflen-len, "p", NULL);
2531 /****************************************************************************
2532 Delete a printer - this just deletes the printer info file, any open
2533 handles are not affected.
2534 ****************************************************************************/
2536 uint32 del_a_printer(const char *sharename)
2539 char *printdb_path = NULL;
2540 TALLOC_CTX *ctx = talloc_tos();
2542 kbuf = make_printer_tdbkey(ctx, sharename);
2543 tdb_delete(tdb_printers, kbuf);
2545 kbuf= make_printers_secdesc_tdbkey(ctx, sharename);
2546 tdb_delete(tdb_printers, kbuf);
2548 close_all_print_db();
2550 if (geteuid() == 0) {
2551 if (asprintf(&printdb_path, "%s%s.tdb",
2552 cache_path("printing/"),
2556 unlink(printdb_path);
2557 SAFE_FREE(printdb_path);
2563 /****************************************************************************
2564 ****************************************************************************/
2565 static WERROR update_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info)
2571 TDB_DATA kbuf, dbuf;
2574 * in addprinter: no servername and the printer is the name
2575 * in setprinter: servername is \\server
2576 * and printer is \\server\\printer
2578 * Samba manages only local printers.
2579 * we currently don't support things like i
2580 * path=\\other_server\printer
2582 * We only store the printername, not \\server\printername
2585 if ( info->servername[0] != '\0' ) {
2586 trim_string(info->printername, info->servername, NULL);
2587 trim_char(info->printername, '\\', '\0');
2588 info->servername[0]='\0';
2592 * JFM: one day I'll forget.
2593 * below that's info->portname because that's the SAMBA sharename
2594 * and I made NT 'thinks' it's the portname
2595 * the info->sharename is the thing you can name when you add a printer
2596 * that's the short-name when you create shared printer for 95/98
2597 * So I've made a limitation in SAMBA: you can only have 1 printer model
2598 * behind a SAMBA share.
2606 len += tdb_pack(buf+len, buflen-len, "dddddddddddfffffPfffff",
2609 info->default_priority,
2626 info->printprocessor,
2630 len += pack_devicemode(info->devmode, buf+len, buflen-len);
2631 retlen = pack_values( info->data, buf+len, buflen-len );
2638 if (buflen != len) {
2639 buf = (uint8 *)SMB_REALLOC(buf, len);
2641 DEBUG(0,("update_a_printer_2: failed to enlarge buffer!\n"));
2649 kbuf = make_printer_tdbkey(talloc_tos(), info->sharename );
2654 ret = (tdb_store(tdb_printers, kbuf, dbuf, TDB_REPLACE) == 0? WERR_OK : WERR_NOMEM);
2657 if (!W_ERROR_IS_OK(ret))
2658 DEBUG(8, ("error updating printer to tdb on disk\n"));
2662 DEBUG(8,("packed printer [%s] with driver [%s] portname=[%s] len=%d\n",
2663 info->sharename, info->drivername, info->portname, len));
2669 /****************************************************************************
2670 Malloc and return an NT devicemode.
2671 ****************************************************************************/
2673 NT_DEVICEMODE *construct_nt_devicemode(const fstring default_devicename)
2676 char adevice[MAXDEVICENAME];
2677 NT_DEVICEMODE *nt_devmode = SMB_MALLOC_P(NT_DEVICEMODE);
2679 if (nt_devmode == NULL) {
2680 DEBUG(0,("construct_nt_devicemode: malloc fail.\n"));
2684 ZERO_STRUCTP(nt_devmode);
2686 slprintf(adevice, sizeof(adevice), "%s", default_devicename);
2687 fstrcpy(nt_devmode->devicename, adevice);
2689 fstrcpy(nt_devmode->formname, "Letter");
2691 nt_devmode->specversion = 0x0401;
2692 nt_devmode->driverversion = 0x0400;
2693 nt_devmode->size = 0x00DC;
2694 nt_devmode->driverextra = 0x0000;
2695 nt_devmode->fields = FORMNAME | TTOPTION | PRINTQUALITY |
2696 DEFAULTSOURCE | COPIES | SCALE |
2697 PAPERSIZE | ORIENTATION;
2698 nt_devmode->orientation = 1;
2699 nt_devmode->papersize = PAPER_LETTER;
2700 nt_devmode->paperlength = 0;
2701 nt_devmode->paperwidth = 0;
2702 nt_devmode->scale = 0x64;
2703 nt_devmode->copies = 1;
2704 nt_devmode->defaultsource = BIN_FORMSOURCE;
2705 nt_devmode->printquality = RES_HIGH; /* 0x0258 */
2706 nt_devmode->color = COLOR_MONOCHROME;
2707 nt_devmode->duplex = DUP_SIMPLEX;
2708 nt_devmode->yresolution = 0;
2709 nt_devmode->ttoption = TT_SUBDEV;
2710 nt_devmode->collate = COLLATE_FALSE;
2711 nt_devmode->icmmethod = 0;
2712 nt_devmode->icmintent = 0;
2713 nt_devmode->mediatype = 0;
2714 nt_devmode->dithertype = 0;
2716 /* non utilisés par un driver d'imprimante */
2717 nt_devmode->logpixels = 0;
2718 nt_devmode->bitsperpel = 0;
2719 nt_devmode->pelswidth = 0;
2720 nt_devmode->pelsheight = 0;
2721 nt_devmode->displayflags = 0;
2722 nt_devmode->displayfrequency = 0;
2723 nt_devmode->reserved1 = 0;
2724 nt_devmode->reserved2 = 0;
2725 nt_devmode->panningwidth = 0;
2726 nt_devmode->panningheight = 0;
2728 nt_devmode->nt_dev_private = NULL;
2732 /****************************************************************************
2733 Deepcopy an NT devicemode.
2734 ****************************************************************************/
2736 NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode)
2738 NT_DEVICEMODE *new_nt_devicemode = NULL;
2740 if ( !nt_devicemode )
2743 if ((new_nt_devicemode = (NT_DEVICEMODE *)memdup(nt_devicemode, sizeof(NT_DEVICEMODE))) == NULL) {
2744 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2748 new_nt_devicemode->nt_dev_private = NULL;
2749 if (nt_devicemode->nt_dev_private != NULL) {
2750 if ((new_nt_devicemode->nt_dev_private = (uint8 *)memdup(nt_devicemode->nt_dev_private, nt_devicemode->driverextra)) == NULL) {
2751 SAFE_FREE(new_nt_devicemode);
2752 DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
2757 return new_nt_devicemode;
2760 /****************************************************************************
2761 Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE.
2762 ****************************************************************************/
2764 void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr)
2766 NT_DEVICEMODE *nt_devmode = *devmode_ptr;
2768 if(nt_devmode == NULL)
2771 DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
2773 SAFE_FREE(nt_devmode->nt_dev_private);
2774 SAFE_FREE(*devmode_ptr);
2777 /****************************************************************************
2778 Clean up and deallocate a (maybe partially) allocated NT_PRINTER_INFO_LEVEL_2.
2779 ****************************************************************************/
2781 static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr)
2783 NT_PRINTER_INFO_LEVEL_2 *info = *info_ptr;
2788 free_nt_devicemode(&info->devmode);
2790 TALLOC_FREE( *info_ptr );
2794 /****************************************************************************
2795 ****************************************************************************/
2796 int unpack_devicemode(NT_DEVICEMODE **nt_devmode, const uint8 *buf, int buflen)
2800 NT_DEVICEMODE devmode;
2802 ZERO_STRUCT(devmode);
2804 len += tdb_unpack(buf+len, buflen-len, "p", nt_devmode);
2806 if (!*nt_devmode) return len;
2808 len += tdb_unpack(buf+len, buflen-len, "ffwwwwwwwwwwwwwwwwwwddddddddddddddp",
2812 &devmode.specversion,
2813 &devmode.driverversion,
2815 &devmode.driverextra,
2816 &devmode.orientation,
2818 &devmode.paperlength,
2819 &devmode.paperwidth,
2822 &devmode.defaultsource,
2823 &devmode.printquality,
2826 &devmode.yresolution,
2832 &devmode.bitsperpel,
2834 &devmode.pelsheight,
2835 &devmode.displayflags,
2836 &devmode.displayfrequency,
2840 &devmode.dithertype,
2843 &devmode.panningwidth,
2844 &devmode.panningheight,
2845 &devmode.nt_dev_private);
2847 if (devmode.nt_dev_private) {
2848 /* the len in tdb_unpack is an int value and
2849 * devmode.driverextra is only a short
2851 len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.nt_dev_private);
2852 devmode.driverextra=(uint16)extra_len;
2854 /* check to catch an invalid TDB entry so we don't segfault */
2855 if (devmode.driverextra == 0) {
2856 devmode.nt_dev_private = NULL;
2860 *nt_devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode));
2862 SAFE_FREE(devmode.nt_dev_private);
2866 DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode.devicename, devmode.formname));
2867 if (devmode.nt_dev_private)
2868 DEBUG(8,("with a private section of %d bytes\n", devmode.driverextra));
2873 /****************************************************************************
2874 Allocate and initialize a new slot.
2875 ***************************************************************************/
2877 int add_new_printer_key( NT_PRINTER_DATA *data, const char *name )
2882 if ( !name || !data )
2885 /* allocate another slot in the NT_PRINTER_KEY array */
2887 if ( !(d = TALLOC_REALLOC_ARRAY( data, data->keys, NT_PRINTER_KEY, data->num_keys+1)) ) {
2888 DEBUG(0,("add_new_printer_key: Realloc() failed!\n"));
2894 key_index = data->num_keys;
2896 /* initialze new key */
2898 data->keys[key_index].name = talloc_strdup( data, name );
2900 if ( !(data->keys[key_index].values = TALLOC_ZERO_P( data, REGVAL_CTR )) )
2905 DEBUG(10,("add_new_printer_key: Inserted new data key [%s]\n", name ));
2910 /****************************************************************************
2911 search for a registry key name in the existing printer data
2912 ***************************************************************************/
2914 int delete_printer_key( NT_PRINTER_DATA *data, const char *name )
2918 for ( i=0; i<data->num_keys; i++ ) {
2919 if ( strequal( data->keys[i].name, name ) ) {
2921 /* cleanup memory */
2923 TALLOC_FREE( data->keys[i].name );
2924 TALLOC_FREE( data->keys[i].values );
2926 /* if not the end of the array, move remaining elements down one slot */
2929 if ( data->num_keys && (i < data->num_keys) )
2930 memmove( &data->keys[i], &data->keys[i+1], sizeof(NT_PRINTER_KEY)*(data->num_keys-i) );
2937 return data->num_keys;
2940 /****************************************************************************
2941 search for a registry key name in the existing printer data
2942 ***************************************************************************/
2944 int lookup_printerkey( NT_PRINTER_DATA *data, const char *name )
2949 if ( !data || !name )
2952 DEBUG(12,("lookup_printerkey: Looking for [%s]\n", name));
2954 /* loop over all existing keys */
2956 for ( i=0; i<data->num_keys; i++ ) {
2957 if ( strequal(data->keys[i].name, name) ) {
2958 DEBUG(12,("lookup_printerkey: Found [%s]!\n", name));
2968 /****************************************************************************
2969 ***************************************************************************/
2971 int get_printer_subkeys( NT_PRINTER_DATA *data, const char* key, fstring **subkeys )
2975 int num_subkeys = 0;
2977 fstring *subkeys_ptr = NULL;
2988 /* special case of asking for the top level printer data registry key names */
2990 if ( strlen(key) == 0 ) {
2991 for ( i=0; i<data->num_keys; i++ ) {
2993 /* found a match, so allocate space and copy the name */
2995 if ( !(subkeys_ptr = SMB_REALLOC_ARRAY( subkeys_ptr, fstring, num_subkeys+2)) ) {
2996 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
3001 fstrcpy( subkeys_ptr[num_subkeys], data->keys[i].name );
3008 /* asking for the subkeys of some key */
3009 /* subkey paths are stored in the key name using '\' as the delimiter */
3011 for ( i=0; i<data->num_keys; i++ ) {
3012 if ( StrnCaseCmp(data->keys[i].name, key, strlen(key)) == 0 ) {
3014 /* if we found the exact key, then break */
3015 key_len = strlen( key );
3016 if ( strlen(data->keys[i].name) == key_len )
3019 /* get subkey path */
3021 p = data->keys[i].name + key_len;
3024 fstrcpy( subkeyname, p );
3025 if ( (p = strchr( subkeyname, '\\' )) )
3028 /* don't add a key more than once */
3030 for ( j=0; j<num_subkeys; j++ ) {
3031 if ( strequal( subkeys_ptr[j], subkeyname ) )
3035 if ( j != num_subkeys )
3038 /* found a match, so allocate space and copy the name */
3040 if ( !(subkeys_ptr = SMB_REALLOC_ARRAY( subkeys_ptr, fstring, num_subkeys+2)) ) {
3041 DEBUG(0,("get_printer_subkeys: Realloc failed for [%d] entries!\n",
3046 fstrcpy( subkeys_ptr[num_subkeys], subkeyname );
3052 /* return error if the key was not found */
3054 if ( i == data->num_keys ) {
3055 SAFE_FREE(subkeys_ptr);
3060 /* tag off the end */
3063 fstrcpy(subkeys_ptr[num_subkeys], "" );
3065 *subkeys = subkeys_ptr;
3071 static void map_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3074 smb_ucs2_t conv_str[1024];
3077 regval_ctr_delvalue(ctr, val_name);
3078 str_size = push_ucs2(NULL, conv_str, sz, sizeof(conv_str),
3079 STR_TERMINATE | STR_NOALIGN);
3080 regval_ctr_addvalue(ctr, val_name, REG_SZ,
3081 (char *) conv_str, str_size);
3084 static void map_dword_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3087 regval_ctr_delvalue(ctr, val_name);
3088 regval_ctr_addvalue(ctr, val_name, REG_DWORD,
3089 (char *) &dword, sizeof(dword));
3092 static void map_bool_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3095 uint8 bin_bool = (b ? 1 : 0);
3096 regval_ctr_delvalue(ctr, val_name);
3097 regval_ctr_addvalue(ctr, val_name, REG_BINARY,
3098 (char *) &bin_bool, sizeof(bin_bool));
3101 static void map_single_multi_sz_into_ctr(REGVAL_CTR *ctr, const char *val_name,
3102 const char *multi_sz)
3104 smb_ucs2_t *conv_strs = NULL;
3107 /* a multi-sz has to have a null string terminator, i.e., the last
3108 string must be followed by two nulls */
3109 str_size = strlen(multi_sz) + 2;
3110 conv_strs = SMB_CALLOC_ARRAY(smb_ucs2_t, str_size);
3115 /* Change to byte units. */
3116 str_size *= sizeof(smb_ucs2_t);
3117 push_ucs2(NULL, conv_strs, multi_sz, str_size,
3118 STR_TERMINATE | STR_NOALIGN);
3120 regval_ctr_delvalue(ctr, val_name);
3121 regval_ctr_addvalue(ctr, val_name, REG_MULTI_SZ,
3122 (char *) conv_strs, str_size);
3123 SAFE_FREE(conv_strs);
3126 /****************************************************************************
3127 * Map the NT_PRINTER_INFO_LEVEL_2 data into DsSpooler keys for publishing.
3129 * @param info2 NT_PRINTER_INFO_LEVEL_2 describing printer - gets modified
3130 * @return bool indicating success or failure
3131 ***************************************************************************/
3133 static bool map_nt_printer_info2_to_dsspooler(NT_PRINTER_INFO_LEVEL_2 *info2)
3135 REGVAL_CTR *ctr = NULL;
3137 const char *dnssuffix;
3138 char *allocated_string = NULL;
3139 const char *ascii_str;
3142 if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
3143 i = add_new_printer_key(info2->data, SPOOL_DSSPOOLER_KEY);
3144 ctr = info2->data->keys[i].values;
3146 map_sz_into_ctr(ctr, SPOOL_REG_PRINTERNAME, info2->sharename);
3147 map_sz_into_ctr(ctr, SPOOL_REG_SHORTSERVERNAME, global_myname());
3149 /* we make the assumption that the netbios name is the same
3150 as the DNS name sinc ethe former will be what we used to
3153 dnssuffix = get_mydnsdomname(talloc_tos());
3154 if (dnssuffix && *dnssuffix) {
3155 fstr_sprintf( longname, "%s.%s", global_myname(), dnssuffix );
3157 fstrcpy( longname, global_myname() );
3160 map_sz_into_ctr(ctr, SPOOL_REG_SERVERNAME, longname);
3162 if (asprintf(&allocated_string, "\\\\%s\\%s", longname, info2->sharename) == -1) {
3165 map_sz_into_ctr(ctr, SPOOL_REG_UNCNAME, allocated_string);
3166 SAFE_FREE(allocated_string);
3168 map_dword_into_ctr(ctr, SPOOL_REG_VERSIONNUMBER, 4);
3169 map_sz_into_ctr(ctr, SPOOL_REG_DRIVERNAME, info2->drivername);
3170 map_sz_into_ctr(ctr, SPOOL_REG_LOCATION, info2->location);
3171 map_sz_into_ctr(ctr, SPOOL_REG_DESCRIPTION, info2->comment);
3172 map_single_multi_sz_into_ctr(ctr, SPOOL_REG_PORTNAME, info2->portname);
3173 map_sz_into_ctr(ctr, SPOOL_REG_PRINTSEPARATORFILE, info2->sepfile);
3174 map_dword_into_ctr(ctr, SPOOL_REG_PRINTSTARTTIME, info2->starttime);
3175 map_dword_into_ctr(ctr, SPOOL_REG_PRINTENDTIME, info2->untiltime);
3176 map_dword_into_ctr(ctr, SPOOL_REG_PRIORITY, info2->priority);
3178 map_bool_into_ctr(ctr, SPOOL_REG_PRINTKEEPPRINTEDJOBS,
3179 (info2->attributes &
3180 PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
3182 switch (info2->attributes & 0x3) {
3184 ascii_str = SPOOL_REGVAL_PRINTWHILESPOOLING;
3187 ascii_str = SPOOL_REGVAL_PRINTAFTERSPOOLED;
3190 ascii_str = SPOOL_REGVAL_PRINTDIRECT;
3193 ascii_str = "unknown";
3195 map_sz_into_ctr(ctr, SPOOL_REG_PRINTSPOOLING, ascii_str);
3200 /*****************************************************************
3201 ****************************************************************/
3203 static void store_printer_guid(NT_PRINTER_INFO_LEVEL_2 *info2,
3207 REGVAL_CTR *ctr=NULL;
3208 UNISTR2 unistr_guid;
3210 /* find the DsSpooler key */
3211 if ((i = lookup_printerkey(info2->data, SPOOL_DSSPOOLER_KEY)) < 0)
3212 i = add_new_printer_key(info2->data, SPOOL_DSSPOOLER_KEY);
3213 ctr = info2->data->keys[i].values;
3215 regval_ctr_delvalue(ctr, "objectGUID");
3217 /* We used to store this as a REG_BINARY but that causes
3220 ZERO_STRUCT( unistr_guid );
3222 init_unistr2( &unistr_guid, GUID_string(talloc_tos(), &guid),
3223 UNI_STR_TERMINATE );
3225 regval_ctr_addvalue(ctr, "objectGUID", REG_SZ,
3226 (char *)unistr_guid.buffer,
3227 unistr_guid.uni_max_len*2);
3231 static WERROR nt_printer_publish_ads(ADS_STRUCT *ads,
3232 NT_PRINTER_INFO_LEVEL *printer)
3236 char *prt_dn = NULL, *srv_dn, *srv_cn_0, *srv_cn_escaped, *sharename_escaped;
3237 char *srv_dn_utf8, **srv_cn_utf8;
3240 const char *attrs[] = {"objectGUID", NULL};
3242 WERROR win_rc = WERR_OK;
3243 size_t converted_size;
3246 DEBUG(5, ("publishing printer %s\n", printer->info_2->printername));
3248 /* figure out where to publish */
3249 ads_find_machine_acct(ads, &res, global_myname());
3251 /* We use ldap_get_dn here as we need the answer
3252 * in utf8 to call ldap_explode_dn(). JRA. */
3254 srv_dn_utf8 = ldap_get_dn((LDAP *)ads->ldap.ld, (LDAPMessage *)res);
3256 return WERR_SERVER_UNAVAILABLE;
3258 ads_msgfree(ads, res);
3259 srv_cn_utf8 = ldap_explode_dn(srv_dn_utf8, 1);
3261 ldap_memfree(srv_dn_utf8);
3262 return WERR_SERVER_UNAVAILABLE;
3264 /* Now convert to CH_UNIX. */
3265 if (!pull_utf8_allocate(&srv_dn, srv_dn_utf8, &converted_size)) {
3266 ldap_memfree(srv_dn_utf8);
3267 ldap_memfree(srv_cn_utf8);
3268 return WERR_SERVER_UNAVAILABLE;
3270 if (!pull_utf8_allocate(&srv_cn_0, srv_cn_utf8[0], &converted_size)) {
3271 ldap_memfree(srv_dn_utf8);
3272 ldap_memfree(srv_cn_utf8);
3274 return WERR_SERVER_UNAVAILABLE;
3277 ldap_memfree(srv_dn_utf8);
3278 ldap_memfree(srv_cn_utf8);
3280 srv_cn_escaped = escape_rdn_val_string_alloc(srv_cn_0);
3281 if (!srv_cn_escaped) {
3282 SAFE_FREE(srv_cn_0);
3284 return WERR_SERVER_UNAVAILABLE;
3286 sharename_escaped = escape_rdn_val_string_alloc(printer->info_2->sharename);
3287 if (!sharename_escaped) {
3288 SAFE_FREE(srv_cn_escaped);
3289 SAFE_FREE(srv_cn_0);
3291 return WERR_SERVER_UNAVAILABLE;
3294 ret = asprintf(&prt_dn, "cn=%s-%s,%s", srv_cn_escaped, sharename_escaped, srv_dn);
3297 SAFE_FREE(srv_cn_0);
3298 SAFE_FREE(srv_cn_escaped);
3299 SAFE_FREE(sharename_escaped);
3305 /* build the ads mods */
3306 ctx = talloc_init("nt_printer_publish_ads");
3312 mods = ads_init_mods(ctx);
3316 talloc_destroy(ctx);
3320 get_local_printer_publishing_data(ctx, &mods, printer->info_2->data);
3321 ads_mod_str(ctx, &mods, SPOOL_REG_PRINTERNAME,
3322 printer->info_2->sharename);
3325 ads_rc = ads_mod_printer_entry(ads, prt_dn, ctx, &mods);
3326 if (ads_rc.err.rc == LDAP_NO_SUCH_OBJECT) {
3328 for (i=0; mods[i] != 0; i++)
3330 mods[i] = (LDAPMod *)-1;
3331 ads_rc = ads_add_printer_entry(ads, prt_dn, ctx, &mods);
3334 if (!ADS_ERR_OK(ads_rc))
3335 DEBUG(3, ("error publishing %s: %s\n", printer->info_2->sharename, ads_errstr(ads_rc)));
3337 talloc_destroy(ctx);
3339 /* retreive the guid and store it locally */
3340 if (ADS_ERR_OK(ads_search_dn(ads, &res, prt_dn, attrs))) {
3342 ads_pull_guid(ads, res, &guid);
3343 ads_msgfree(ads, res);
3344 store_printer_guid(printer->info_2, guid);
3345 win_rc = mod_a_printer(printer, 2);
3352 static WERROR nt_printer_unpublish_ads(ADS_STRUCT *ads,
3353 NT_PRINTER_INFO_LEVEL *printer)
3356 LDAPMessage *res = NULL;
3357 char *prt_dn = NULL;
3359 DEBUG(5, ("unpublishing printer %s\n", printer->info_2->printername));
3361 /* remove the printer from the directory */
3362 ads_rc = ads_find_printer_on_server(ads, &res,
3363 printer->info_2->sharename, global_myname());
3365 if (ADS_ERR_OK(ads_rc) && res && ads_count_replies(ads, res)) {
3366 prt_dn = ads_get_dn(ads, res);
3368 ads_msgfree(ads, res);
3371 ads_rc = ads_del_dn(ads, prt_dn);
3372 ads_memfree(ads, prt_dn);
3376 ads_msgfree(ads, res);
3381 /****************************************************************************
3382 * Publish a printer in the directory
3384 * @param snum describing printer service
3385 * @return WERROR indicating status of publishing
3386 ***************************************************************************/
3388 WERROR nt_printer_publish(Printer_entry *print_hnd, int snum, int action)
3391 ADS_STRUCT *ads = NULL;
3392 NT_PRINTER_INFO_LEVEL *printer = NULL;
3395 win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
3396 if (!W_ERROR_IS_OK(win_rc))
3400 case DSPRINT_PUBLISH:
3401 case DSPRINT_UPDATE:
3402 /* set the DsSpooler info and attributes */
3403 if (!(map_nt_printer_info2_to_dsspooler(printer->info_2))) {
3404 win_rc = WERR_NOMEM;
3408 printer->info_2->attributes |= PRINTER_ATTRIBUTE_PUBLISHED;
3410 case DSPRINT_UNPUBLISH:
3411 printer->info_2->attributes ^= PRINTER_ATTRIBUTE_PUBLISHED;
3414 win_rc = WERR_NOT_SUPPORTED;
3418 win_rc = mod_a_printer(printer, 2);
3419 if (!W_ERROR_IS_OK(win_rc)) {
3420 DEBUG(3, ("err %d saving data\n", W_ERROR_V(win_rc)));
3424 ads = ads_init(lp_realm(), lp_workgroup(), NULL);
3426 DEBUG(3, ("ads_init() failed\n"));
3427 win_rc = WERR_SERVER_UNAVAILABLE;
3430 setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
3431 SAFE_FREE(ads->auth.password);
3432 ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
3435 /* ads_connect() will find the DC for us */
3436 ads_rc = ads_connect(ads);
3437 if (!ADS_ERR_OK(ads_rc)) {
3438 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
3439 win_rc = WERR_ACCESS_DENIED;
3444 case DSPRINT_PUBLISH:
3445 case DSPRINT_UPDATE:
3446 win_rc = nt_printer_publish_ads(ads, printer);
3448 case DSPRINT_UNPUBLISH:
3449 win_rc = nt_printer_unpublish_ads(ads, printer);
3454 free_a_printer(&printer, 2);
3459 WERROR check_published_printers(void)
3462 ADS_STRUCT *ads = NULL;
3464 int n_services = lp_numservices();
3465 NT_PRINTER_INFO_LEVEL *printer = NULL;
3467 ads = ads_init(lp_realm(), lp_workgroup(), NULL);
3469 DEBUG(3, ("ads_init() failed\n"));
3470 return WERR_SERVER_UNAVAILABLE;
3472 setenv(KRB5_ENV_CCNAME, "MEMORY:prtpub_cache", 1);
3473 SAFE_FREE(ads->auth.password);
3474 ads->auth.password = secrets_fetch_machine_password(lp_workgroup(),
3477 /* ads_connect() will find the DC for us */
3478 ads_rc = ads_connect(ads);
3479 if (!ADS_ERR_OK(ads_rc)) {
3480 DEBUG(3, ("ads_connect failed: %s\n", ads_errstr(ads_rc)));
3482 ads_kdestroy("MEMORY:prtpub_cache");
3483 return WERR_ACCESS_DENIED;
3486 for (snum = 0; snum < n_services; snum++) {
3487 if (!(lp_snum_ok(snum) && lp_print_ok(snum)))
3490 if (W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2,
3491 lp_servicename(snum))) &&
3492 (printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED))
3493 nt_printer_publish_ads(ads, printer);
3495 free_a_printer(&printer, 2);
3499 ads_kdestroy("MEMORY:prtpub_cache");
3503 bool is_printer_published(Printer_entry *print_hnd, int snum,
3506 NT_PRINTER_INFO_LEVEL *printer = NULL;
3508 REGISTRY_VALUE *guid_val;
3513 win_rc = get_a_printer(print_hnd, &printer, 2, lp_servicename(snum));
3515 if (!W_ERROR_IS_OK(win_rc) ||
3516 !(printer->info_2->attributes & PRINTER_ATTRIBUTE_PUBLISHED) ||
3517 ((i = lookup_printerkey(printer->info_2->data, SPOOL_DSSPOOLER_KEY)) < 0) ||
3518 !(ctr = printer->info_2->data->keys[i].values) ||
3519 !(guid_val = regval_ctr_getvalue(ctr, "objectGUID")))
3521 free_a_printer(&printer, 2);
3525 /* fetching printer guids really ought to be a separate function. */
3530 /* We used to store the guid as REG_BINARY, then swapped
3531 to REG_SZ for Vista compatibility so check for both */
3533 switch ( regval_type(guid_val) ){
3535 rpcstr_pull( guid_str, regval_data_p(guid_val),
3536 sizeof(guid_str)-1, -1, STR_TERMINATE );
3537 ret = NT_STATUS_IS_OK(GUID_from_string( guid_str, guid ));
3540 if ( regval_size(guid_val) != sizeof(struct GUID) ) {
3544 memcpy(guid, regval_data_p(guid_val), sizeof(struct GUID));
3547 DEBUG(0,("is_printer_published: GUID value stored as "
3548 "invaluid type (%d)\n", regval_type(guid_val) ));
3553 free_a_printer(&printer, 2);
3557 WERROR nt_printer_publish(Printer_entry *print_hnd, int snum, int action)
3562 WERROR check_published_printers(void)
3567 bool is_printer_published(Printer_entry *print_hnd, int snum,
3572 #endif /* HAVE_ADS */
3574 /****************************************************************************
3575 ***************************************************************************/
3577 WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key )
3579 NT_PRINTER_DATA *data;
3581 int removed_keys = 0;
3585 empty_slot = data->num_keys;
3588 return WERR_INVALID_PARAM;
3590 /* remove all keys */
3592 if ( !strlen(key) ) {
3594 TALLOC_FREE( data );
3598 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from printer [%s]\n",
3604 /* remove a specific key (and all subkeys) */
3606 for ( i=0; i<data->num_keys; i++ ) {
3607 if ( StrnCaseCmp( data->keys[i].name, key, strlen(key)) == 0 ) {
3608 DEBUG(8,("delete_all_printer_data: Removed all Printer Data from key [%s]\n",
3609 data->keys[i].name));
3611 TALLOC_FREE( data->keys[i].name );
3612 TALLOC_FREE( data->keys[i].values );
3614 /* mark the slot as empty */
3616 ZERO_STRUCTP( &data->keys[i] );
3620 /* find the first empty slot */
3622 for ( i=0; i<data->num_keys; i++ ) {
3623 if ( !data->keys[i].name ) {
3630 if ( i == data->num_keys )
3631 /* nothing was removed */
3632 return WERR_INVALID_PARAM;
3634 /* move everything down */
3636 for ( i=empty_slot+1; i<data->num_keys; i++ ) {
3637 if ( data->keys[i].name ) {
3638 memcpy( &data->keys[empty_slot], &data->keys[i], sizeof(NT_PRINTER_KEY) );
3639 ZERO_STRUCTP( &data->keys[i] );
3647 data->num_keys -= removed_keys;
3649 /* sanity check to see if anything is left */
3651 if ( !data->num_keys ) {
3652 DEBUG(8,("delete_all_printer_data: No keys left for printer [%s]\n", p2->printername ));
3654 SAFE_FREE( data->keys );
3655 ZERO_STRUCTP( data );
3661 /****************************************************************************
3662 ***************************************************************************/
3664 WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
3666 WERROR result = WERR_OK;
3669 /* we must have names on non-zero length */
3671 if ( !key || !*key|| !value || !*value )
3672 return WERR_INVALID_NAME;
3674 /* find the printer key first */
3676 key_index = lookup_printerkey( p2->data, key );
3677 if ( key_index == -1 )
3680 /* make sure the value exists so we can return the correct error code */
3682 if ( !regval_ctr_getvalue( p2->data->keys[key_index].values, value ) )
3683 return WERR_BADFILE;
3685 regval_ctr_delvalue( p2->data->keys[key_index].values, value );
3687 DEBUG(8,("delete_printer_data: Removed key => [%s], value => [%s]\n",
3693 /****************************************************************************
3694 ***************************************************************************/
3696 WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value,
3697 uint32 type, uint8 *data, int real_len )
3699 WERROR result = WERR_OK;
3702 /* we must have names on non-zero length */
3704 if ( !key || !*key|| !value || !*value )
3705 return WERR_INVALID_NAME;
3707 /* find the printer key first */
3709 key_index = lookup_printerkey( p2->data, key );
3710 if ( key_index == -1 )
3711 key_index = add_new_printer_key( p2->data, key );
3713 if ( key_index == -1 )
3716 regval_ctr_addvalue( p2->data->keys[key_index].values, value,
3717 type, (const char *)data, real_len );
3719 DEBUG(8,("add_printer_data: Added key => [%s], value => [%s], type=> [%d], size => [%d]\n",
3720 key, value, type, real_len ));
3725 /****************************************************************************
3726 ***************************************************************************/
3728 REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
3732 if ( (key_index = lookup_printerkey( p2->data, key )) == -1 )
3735 DEBUG(8,("get_printer_data: Attempting to lookup key => [%s], value => [%s]\n",
3738 return regval_ctr_getvalue( p2->data->keys[key_index].values, value );
3741 /****************************************************************************
3742 Unpack a list of registry values frem the TDB
3743 ***************************************************************************/
3745 static int unpack_values(NT_PRINTER_DATA *printer_data, const uint8 *buf, int buflen)
3750 const char *valuename = NULL;
3751 const char *keyname = NULL;
3755 REGISTRY_VALUE *regval_p;
3758 /* add the "PrinterDriverData" key first for performance reasons */
3760 add_new_printer_key( printer_data, SPOOL_PRINTERDATA_KEY );
3762 /* loop and unpack the rest of the registry values */
3766 /* check to see if there are any more registry values */
3769 len += tdb_unpack(buf+len, buflen-len, "p", ®val_p);
3773 /* unpack the next regval */
3775 len += tdb_unpack(buf+len, buflen-len, "fdB",
3781 /* lookup for subkey names which have a type of REG_NONE */
3782 /* there's no data with this entry */
3784 if ( type == REG_NONE ) {
3785 if ( (key_index=lookup_printerkey( printer_data, string)) == -1 )
3786 add_new_printer_key( printer_data, string );
3791 * break of the keyname from the value name.
3792 * Valuenames can have embedded '\'s so be careful.
3793 * only support one level of keys. See the
3794 * "Konica Fiery S300 50C-K v1.1. enu" 2k driver.
3798 str = strchr_m( string, '\\');
3800 /* Put in "PrinterDriverData" is no key specified */
3803 keyname = SPOOL_PRINTERDATA_KEY;
3812 /* see if we need a new key */
3814 if ( (key_index=lookup_printerkey( printer_data, keyname )) == -1 )
3815 key_index = add_new_printer_key( printer_data, keyname );
3817 if ( key_index == -1 ) {
3818 DEBUG(0,("unpack_values: Failed to allocate a new key [%s]!\n",
3823 DEBUG(8,("specific: [%s:%s], len: %d\n", keyname, valuename, size));
3825 /* Vista doesn't like unknown REG_BINARY values in DsSpooler.
3826 Thanks to Martin Zielinski for the hint. */
3828 if ( type == REG_BINARY &&
3829 strequal( keyname, SPOOL_DSSPOOLER_KEY ) &&
3830 strequal( valuename, "objectGUID" ) )
3833 UNISTR2 unistr_guid;
3835 ZERO_STRUCT( unistr_guid );
3837 /* convert the GUID to a UNICODE string */
3839 memcpy( &guid, data_p, sizeof(struct GUID) );
3841 init_unistr2( &unistr_guid,
3842 GUID_string(talloc_tos(), &guid),
3843 UNI_STR_TERMINATE );
3845 regval_ctr_addvalue( printer_data->keys[key_index].values,
3847 (const char *)unistr_guid.buffer,
3848 unistr_guid.uni_str_len*2 );
3853 regval_ctr_addvalue( printer_data->keys[key_index].values,
3854 valuename, type, (const char *)data_p,
3858 SAFE_FREE(data_p); /* 'B' option to tdbpack does a malloc() */
3865 /****************************************************************************
3866 ***************************************************************************/
3868 static char *last_from;
3869 static char *last_to;
3871 static const char *get_last_from(void)
3879 static const char *get_last_to(void)
3887 static bool set_last_from_to(const char *from, const char *to)
3889 char *orig_from = last_from;
3890 char *orig_to = last_to;
3892 last_from = SMB_STRDUP(from);
3893 last_to = SMB_STRDUP(to);
3895 SAFE_FREE(orig_from);
3898 if (!last_from || !last_to) {
3899 SAFE_FREE(last_from);
3906 static void map_to_os2_driver(fstring drivername)
3908 char *mapfile = lp_os2_driver_map();
3909 char **lines = NULL;
3913 if (!strlen(drivername))
3919 if (strequal(drivername,get_last_from())) {
3920 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",
3921 drivername,get_last_to()));
3922 fstrcpy(drivername,get_last_to());
3926 lines = file_lines_load(mapfile, &numlines,0,NULL);
3927 if (numlines == 0 || lines == NULL) {
3928 DEBUG(0,("No entries in OS/2 driver map %s\n",mapfile));
3933 DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile));
3935 for( i = 0; i < numlines; i++) {
3936 char *nt_name = lines[i];
3937 char *os2_name = strchr(nt_name,'=');
3944 while (isspace(*nt_name))
3947 if (!*nt_name || strchr("#;",*nt_name))
3951 int l = strlen(nt_name);
3952 while (l && isspace(nt_name[l-1])) {
3958 while (isspace(*os2_name))
3962 int l = strlen(os2_name);
3963 while (l && isspace(os2_name[l-1])) {
3969 if (strequal(nt_name,drivername)) {
3970 DEBUG(3,("Mapped windows driver %s to os2 driver%s\n",drivername,os2_name));
3971 set_last_from_to(drivername,os2_name);
3972 fstrcpy(drivername,os2_name);
3981 /****************************************************************************
3982 Get a default printer info 2 struct.
3983 ****************************************************************************/
3985 static WERROR get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 *info,
3986 const char *servername,
3987 const char* sharename,
3990 int snum = lp_servicenumber(sharename);
3992 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", servername);
3993 slprintf(info->printername, sizeof(info->printername)-1, "\\\\%s\\%s",
3994 servername, sharename);
3995 fstrcpy(info->sharename, sharename);
3996 fstrcpy(info->portname, SAMBA_PRINTER_PORT_NAME);
3998 /* by setting the driver name to an empty string, a local NT admin
3999 can now run the **local** APW to install a local printer driver
4000 for a Samba shared printer in 2.2. Without this, drivers **must** be
4001 installed on the Samba server for NT clients --jerry */
4002 #if 0 /* JERRY --do not uncomment-- */
4003 if (!*info->drivername)
4004 fstrcpy(info->drivername, "NO DRIVER AVAILABLE FOR THIS PRINTER");
4008 DEBUG(10,("get_a_printer_2_default: driver name set to [%s]\n", info->drivername));
4010 strlcpy(info->comment, "", sizeof(info->comment));
4011 fstrcpy(info->printprocessor, "winprint");
4012 fstrcpy(info->datatype, "RAW");
4015 if (get_loc_com && (enum printing_types)lp_printing(snum) == PRINT_CUPS ) {
4016 /* Pull the location and comment strings from cups if we don't
4018 if ( !strlen(info->location) || !strlen(info->comment) )
4019 cups_pull_comment_location( info );
4023 info->attributes = PRINTER_ATTRIBUTE_SAMBA;
4025 info->starttime = 0; /* Minutes since 12:00am GMT */
4026 info->untiltime = 0; /* Minutes since 12:00am GMT */
4028 info->default_priority = 1;
4029 info->setuptime = (uint32)time(NULL);
4032 * I changed this as I think it is better to have a generic
4033 * DEVMODE than to crash Win2k explorer.exe --jerry
4034 * See the HP Deskjet 990c Win2k drivers for an example.
4036 * However the default devmode appears to cause problems
4037 * with the HP CLJ 8500 PCL driver. Hence the addition of
4038 * the "default devmode" parameter --jerry 22/01/2002
4041 if (lp_default_devmode(snum)) {
4042 if ((info->devmode = construct_nt_devicemode(info->printername)) == NULL) {
4046 info->devmode = NULL;
4049 if (!nt_printing_getsec(info, sharename, &info->secdesc_buf)) {
4057 free_nt_devicemode(&info->devmode);
4059 return WERR_ACCESS_DENIED;
4062 /****************************************************************************
4063 ****************************************************************************/
4065 static WERROR get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info,
4066 const char *servername,
4067 const char *sharename,
4071 int snum = lp_servicenumber(sharename);
4072 TDB_DATA kbuf, dbuf;
4073 fstring printername;
4074 char adevice[MAXDEVICENAME];
4075 char *comment = NULL;
4077 kbuf = make_printer_tdbkey(talloc_tos(), sharename);
4079 dbuf = tdb_fetch(tdb_printers, kbuf);
4081 return get_a_printer_2_default(info, servername,
4082 sharename, get_loc_com);
4085 len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "dddddddddddfffffPfffff",
4088 &info->default_priority,
4095 &info->c_setprinter,
4105 info->printprocessor,
4110 strlcpy(info->comment, comment, sizeof(info->comment));
4114 /* Samba has to have shared raw drivers. */
4115 info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
4116 info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
4118 /* Restore the stripped strings. */
4119 slprintf(info->servername, sizeof(info->servername)-1, "\\\\%s", servername);
4121 if ( lp_force_printername(snum) ) {
4122 slprintf(printername, sizeof(printername)-1, "\\\\%s\\%s", servername, sharename );
4124 slprintf(printername, sizeof(printername)-1, "\\\\%s\\%s", servername, info->printername);
4127 fstrcpy(info->printername, printername);
4130 if (get_loc_com && (enum printing_types)lp_printing(snum) == PRINT_CUPS ) {
4131 /* Pull the location and comment strings from cups if we don't
4133 if ( !strlen(info->location) || !strlen(info->comment) )
4134 cups_pull_comment_location( info );
4138 len += unpack_devicemode(&info->devmode,dbuf.dptr+len, dbuf.dsize-len);
4141 * Some client drivers freak out if there is a NULL devmode
4142 * (probably the driver is not checking before accessing
4143 * the devmode pointer) --jerry
4145 * See comments in get_a_printer_2_default()
4148 if (lp_default_devmode(snum) && !info->devmode) {
4149 DEBUG(8,("get_a_printer_2: Constructing a default device mode for [%s]\n",
4151 info->devmode = construct_nt_devicemode(printername);
4154 slprintf( adevice, sizeof(adevice), "%s", info->printername );
4155 if (info->devmode) {
4156 fstrcpy(info->devmode->devicename, adevice);
4159 if ( !(info->data = TALLOC_ZERO_P( info, NT_PRINTER_DATA )) ) {
4160 DEBUG(0,("unpack_values: talloc() failed!\n"));
4161 SAFE_FREE(dbuf.dptr);
4164 len += unpack_values( info->data, dbuf.dptr+len, dbuf.dsize-len );
4166 /* This will get the current RPC talloc context, but we should be
4167 passing this as a parameter... fixme... JRA ! */
4169 if (!nt_printing_getsec(info, sharename, &info->secdesc_buf)) {
4170 SAFE_FREE(dbuf.dptr);
4174 /* Fix for OS/2 drivers. */
4176 if (get_remote_arch() == RA_OS2) {
4177 map_to_os2_driver(info->drivername);
4180 SAFE_FREE(dbuf.dptr);
4182 DEBUG(9,("Unpacked printer [%s] name [%s] running driver [%s]\n",
4183 sharename, info->printername, info->drivername));
4188 /****************************************************************************
4189 Debugging function, dump at level 6 the struct in the logs.
4190 ****************************************************************************/
4191 static uint32 dump_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4194 NT_PRINTER_INFO_LEVEL_2 *info2;
4196 DEBUG(106,("Dumping printer at level [%d]\n", level));
4201 if (printer->info_2 == NULL)
4205 info2=printer->info_2;
4207 DEBUGADD(106,("attributes:[%d]\n", info2->attributes));
4208 DEBUGADD(106,("priority:[%d]\n", info2->priority));
4209 DEBUGADD(106,("default_priority:[%d]\n", info2->default_priority));
4210 DEBUGADD(106,("starttime:[%d]\n", info2->starttime));
4211 DEBUGADD(106,("untiltime:[%d]\n", info2->untiltime));
4212 DEBUGADD(106,("status:[%d]\n", info2->status));
4213 DEBUGADD(106,("cjobs:[%d]\n", info2->cjobs));
4214 DEBUGADD(106,("averageppm:[%d]\n", info2->averageppm));
4215 DEBUGADD(106,("changeid:[%d]\n", info2->changeid));
4216 DEBUGADD(106,("c_setprinter:[%d]\n", info2->c_setprinter));
4217 DEBUGADD(106,("setuptime:[%d]\n", info2->setuptime));
4219 DEBUGADD(106,("servername:[%s]\n", info2->servername));
4220 DEBUGADD(106,("printername:[%s]\n", info2->printername));
4221 DEBUGADD(106,("sharename:[%s]\n", info2->sharename));
4222 DEBUGADD(106,("portname:[%s]\n", info2->portname));
4223 DEBUGADD(106,("drivername:[%s]\n", info2->drivername));
4224 DEBUGADD(106,("comment:[%s]\n", info2->comment));
4225 DEBUGADD(106,("location:[%s]\n", info2->location));
4226 DEBUGADD(106,("sepfile:[%s]\n", info2->sepfile));
4227 DEBUGADD(106,("printprocessor:[%s]\n", info2->printprocessor));
4228 DEBUGADD(106,("datatype:[%s]\n", info2->datatype));
4229 DEBUGADD(106,("parameters:[%s]\n", info2->parameters));
4235 DEBUGADD(106,("dump_a_printer: Level %u not implemented\n", (unsigned int)level ));
4243 /****************************************************************************
4244 Update the changeid time.
4245 This is SO NASTY as some drivers need this to change, others need it
4246 static. This value will change every second, and I must hope that this
4247 is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
4249 ****************************************************************************/
4251 static uint32 rev_changeid(void)
4255 get_process_uptime(&tv);
4258 /* Return changeid as msec since spooler restart */
4259 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
4262 * This setting seems to work well but is too untested
4263 * to replace the above calculation. Left in for experiementation
4264 * of the reader --jerry (Tue Mar 12 09:15:05 CST 2002)
4266 return tv.tv_sec * 10 + tv.tv_usec / 100000;
4272 * The function below are the high level ones.
4273 * only those ones must be called from the spoolss code.
4277 /****************************************************************************
4278 Modify a printer. This is called from SETPRINTERDATA/DELETEPRINTERDATA.
4279 ****************************************************************************/
4281 WERROR mod_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4285 dump_a_printer(printer, level);
4291 * Update the changestamp. Emperical tests show that the
4292 * ChangeID is always updated,but c_setprinter is
4293 * global spooler variable (not per printer).
4296 /* ChangeID **must** be increasing over the lifetime
4297 of client's spoolss service in order for the
4298 client's cache to show updates */
4300 printer->info_2->changeid = rev_changeid();
4303 * Because one day someone will ask:
4304 * NT->NT An admin connection to a remote
4305 * printer show changes imeediately in
4306 * the properities dialog
4308 * A non-admin connection will only show the
4309 * changes after viewing the properites page
4310 * 2 times. Seems to be related to a
4311 * race condition in the client between the spooler
4312 * updating the local cache and the Explorer.exe GUI
4313 * actually displaying the properties.
4315 * This is fixed in Win2k. admin/non-admin
4316 * connections both display changes immediately.
4321 result=update_a_printer_2(printer->info_2);
4325 result=WERR_UNKNOWN_LEVEL;
4332 /****************************************************************************
4333 Initialize printer devmode & data with previously saved driver init values.
4334 ****************************************************************************/
4336 static bool set_driver_init_2( NT_PRINTER_INFO_LEVEL_2 *info_ptr )
4341 NT_PRINTER_INFO_LEVEL_2 info;
4347 * Delete any printer data 'values' already set. When called for driver
4348 * replace, there will generally be some, but during an add printer, there
4349 * should not be any (if there are delete them).
4352 if ( info_ptr->data )
4353 delete_all_printer_data( info_ptr, "" );
4355 if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX,
4356 info_ptr->drivername) < 0) {
4360 dbuf = tdb_fetch_bystring(tdb_drivers, key);
4363 * When changing to a driver that has no init info in the tdb, remove
4364 * the previous drivers init info and leave the new on blank.
4366 free_nt_devicemode(&info_ptr->devmode);
4373 * Get the saved DEVMODE..
4376 len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
4379 * The saved DEVMODE contains the devicename from the printer used during
4380 * the initialization save. Change it to reflect the new printer.
4383 if ( info.devmode ) {
4384 ZERO_STRUCT(info.devmode->devicename);
4385 fstrcpy(info.devmode->devicename, info_ptr->printername);
4389 * NT/2k does not change out the entire DeviceMode of a printer
4390 * when changing the driver. Only the driverextra, private, &
4391 * driverversion fields. --jerry (Thu Mar 14 08:58:43 CST 2002)
4393 * Later examination revealed that Windows NT/2k does reset the
4394 * the printer's device mode, bit **only** when you change a
4395 * property of the device mode such as the page orientation.
4400 /* Bind the saved DEVMODE to the new the printer */
4402 free_nt_devicemode(&info_ptr->devmode);
4403 info_ptr->devmode = info.devmode;
4405 DEBUG(10,("set_driver_init_2: Set printer [%s] init %s DEVMODE for driver [%s]\n",
4406 info_ptr->printername, info_ptr->devmode?"VALID":"NULL", info_ptr->drivername));
4408 /* Add the printer data 'values' to the new printer */
4410 if ( !(info_ptr->data = TALLOC_ZERO_P( info_ptr, NT_PRINTER_DATA )) ) {
4411 DEBUG(0,("set_driver_init_2: talloc() failed!\n"));
4415 len += unpack_values( info_ptr->data, dbuf.dptr+len, dbuf.dsize-len );
4417 SAFE_FREE(dbuf.dptr);
4422 /****************************************************************************
4423 Initialize printer devmode & data with previously saved driver init values.
4424 When a printer is created using AddPrinter, the drivername bound to the
4425 printer is used to lookup previously saved driver initialization info, which
4426 is bound to the new printer.
4427 ****************************************************************************/
4429 bool set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4431 bool result = False;
4435 result = set_driver_init_2(printer->info_2);
4439 DEBUG(0,("set_driver_init: Programmer's error! Unknown driver_init level [%d]\n",
4447 /****************************************************************************
4448 Delete driver init data stored for a specified driver
4449 ****************************************************************************/
4451 bool del_driver_init(char *drivername)
4456 if (!drivername || !*drivername) {
4457 DEBUG(3,("del_driver_init: No drivername specified!\n"));
4461 if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX, drivername) < 0) {
4465 DEBUG(6,("del_driver_init: Removing driver init data for [%s]\n",
4468 ret = (tdb_delete_bystring(tdb_drivers, key) == 0);
4473 /****************************************************************************
4474 Pack up the DEVMODE and values for a printer into a 'driver init' entry
4475 in the tdb. Note: this is different from the driver entry and the printer
4476 entry. There should be a single driver init entry for each driver regardless
4477 of whether it was installed from NT or 2K. Technically, they should be
4478 different, but they work out to the same struct.
4479 ****************************************************************************/
4481 static uint32 update_driver_init_2(NT_PRINTER_INFO_LEVEL_2 *info)
4485 int buflen, len, ret;
4494 len += pack_devicemode(info->devmode, buf+len, buflen-len);
4496 retlen = pack_values( info->data, buf+len, buflen-len );
4504 buf = (uint8 *)SMB_REALLOC(buf, len);
4506 DEBUG(0, ("update_driver_init_2: failed to enlarge buffer!\n"));
4515 if (asprintf(&key, "%s%s", DRIVER_INIT_PREFIX, info->drivername) < 0) {
4523 ret = tdb_store_bystring(tdb_drivers, key, dbuf, TDB_REPLACE);
4527 DEBUG(8, ("update_driver_init_2: error updating printer init to tdb on disk\n"));
4531 DEBUG(10,("update_driver_init_2: Saved printer [%s] init DEVMODE & values for driver [%s]\n",
4532 info->sharename, info->drivername));
4537 /****************************************************************************
4538 Update (i.e. save) the driver init info (DEVMODE and values) for a printer
4539 ****************************************************************************/
4541 static uint32 update_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
4545 dump_a_printer(printer, level);
4549 result = update_driver_init_2(printer->info_2);
4559 /****************************************************************************
4560 Convert the printer data value, a REG_BINARY array, into an initialization
4561 DEVMODE. Note: the array must be parsed as if it was a DEVMODE in an rpc...
4562 got to keep the endians happy :).
4563 ****************************************************************************/
4565 static bool convert_driver_init(TALLOC_CTX *mem_ctx, NT_DEVICEMODE *nt_devmode,
4566 const uint8_t *data, uint32_t data_len)
4568 struct spoolss_DeviceMode devmode;
4569 enum ndr_err_code ndr_err;
4572 ZERO_STRUCT(devmode);
4574 blob = data_blob_const(data, data_len);
4576 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &devmode,
4577 (ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);
4578 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4579 DEBUG(10,("convert_driver_init: error parsing spoolss_DeviceMode\n"));
4583 return convert_devicemode("", &devmode, &nt_devmode);
4586 /****************************************************************************
4587 Set the DRIVER_INIT info in the tdb. Requires Win32 client code that:
4589 1. Use the driver's config DLL to this UNC printername and:
4590 a. Call DrvPrintEvent with PRINTER_EVENT_INITIALIZE
4591 b. Call DrvConvertDevMode with CDM_DRIVER_DEFAULT to get default DEVMODE
4592 2. Call SetPrinterData with the 'magic' key and the DEVMODE as data.
4594 The last step triggers saving the "driver initialization" information for
4595 this printer into the tdb. Later, new printers that use this driver will
4596 have this initialization information bound to them. This simulates the
4597 driver initialization, as if it had run on the Samba server (as it would
4600 The Win32 client side code requirement sucks! But until we can run arbitrary
4601 Win32 printer driver code on any Unix that Samba runs on, we are stuck with it.
4603 It would have been easier to use SetPrinter because all the UNMARSHALLING of
4604 the DEVMODE is done there, but 2K/XP clients do not set the DEVMODE... think
4605 about it and you will realize why. JRR 010720
4606 ****************************************************************************/
4608 static WERROR save_driver_init_2(NT_PRINTER_INFO_LEVEL *printer, uint8 *data, uint32 data_len )
4610 WERROR status = WERR_OK;
4611 TALLOC_CTX *ctx = NULL;
4612 NT_DEVICEMODE *nt_devmode = NULL;
4613 NT_DEVICEMODE *tmp_devmode = printer->info_2->devmode;
4616 * When the DEVMODE is already set on the printer, don't try to unpack it.
4618 DEBUG(8,("save_driver_init_2: Enter...\n"));
4620 if ( !printer->info_2->devmode && data_len ) {
4622 * Set devmode on printer info, so entire printer initialization can be
4626 if ((ctx = talloc_init("save_driver_init_2")) == NULL)
4629 if ((nt_devmode = SMB_MALLOC_P(NT_DEVICEMODE)) == NULL) {
4630 status = WERR_NOMEM;
4634 ZERO_STRUCTP(nt_devmode);
4637 * The DEVMODE is held in the 'data' component of the param in raw binary.
4638 * Convert it to to a devmode structure
4640 if ( !convert_driver_init( ctx, nt_devmode, data, data_len )) {
4641 DEBUG(10,("save_driver_init_2: error converting DEVMODE\n"));
4642 status = WERR_INVALID_PARAM;
4646 printer->info_2->devmode = nt_devmode;
4650 * Pack up and add (or update) the DEVMODE and any current printer data to
4651 * a 'driver init' element in the tdb
4655 if ( update_driver_init(printer, 2) != 0 ) {
4656 DEBUG(10,("save_driver_init_2: error updating DEVMODE\n"));
4657 status = WERR_NOMEM;
4662 * If driver initialization info was successfully saved, set the current
4663 * printer to match it. This allows initialization of the current printer
4664 * as well as the driver.
4666 status = mod_a_printer(printer, 2);
4667 if (!W_ERROR_IS_OK(status)) {
4668 DEBUG(10,("save_driver_init_2: error setting DEVMODE on printer [%s]\n",
4669 printer->info_2->printername));
4673 talloc_destroy(ctx);
4674 free_nt_devicemode( &nt_devmode );
4676 printer->info_2->devmode = tmp_devmode;
4681 /****************************************************************************
4682 Update the driver init info (DEVMODE and specifics) for a printer
4683 ****************************************************************************/
4685 WERROR save_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level, uint8 *data, uint32 data_len)
4687 WERROR status = WERR_OK;
4691 status = save_driver_init_2( printer, data, data_len );
4694 status = WERR_UNKNOWN_LEVEL;
4701 /****************************************************************************
4702 Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory.
4704 Previously the code had a memory allocation problem because it always
4705 used the TALLOC_CTX from the Printer_entry*. This context lasts
4706 as a long as the original handle is open. So if the client made a lot
4707 of getprinter[data]() calls, the memory usage would climb. Now we use
4708 a short lived TALLOC_CTX for printer_info_2 objects returned. We
4709 still use the Printer_entry->ctx for maintaining the cache copy though
4710 since that object must live as long as the handle by definition.
4713 ****************************************************************************/
4715 static WERROR get_a_printer_internal( Printer_entry *print_hnd, NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level,
4716 const char *sharename, bool get_loc_com)
4721 DEBUG(10,("get_a_printer: [%s] level %u\n", sharename, (unsigned int)level));
4723 if ( !(*pp_printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
4724 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4730 if ( !((*pp_printer)->info_2 = TALLOC_ZERO_P(*pp_printer, NT_PRINTER_INFO_LEVEL_2)) ) {
4731 DEBUG(0,("get_a_printer: talloc() fail.\n"));
4732 TALLOC_FREE( *pp_printer );
4737 fstrcpy( servername, print_hnd->servername );
4739 fstrcpy( servername, "%L" );
4740 standard_sub_basic( "", "", servername,
4741 sizeof(servername)-1 );
4744 result = get_a_printer_2( (*pp_printer)->info_2,
4745 servername, sharename, get_loc_com);
4747 /* we have a new printer now. Save it with this handle */
4749 if ( !W_ERROR_IS_OK(result) ) {
4750 TALLOC_FREE( *pp_printer );
4751 DEBUG(10,("get_a_printer: [%s] level %u returning %s\n",
4752 sharename, (unsigned int)level, win_errstr(result)));
4756 dump_a_printer( *pp_printer, level);
4761 TALLOC_FREE( *pp_printer );
4762 return WERR_UNKNOWN_LEVEL;
4768 WERROR get_a_printer( Printer_entry *print_hnd,
4769 NT_PRINTER_INFO_LEVEL **pp_printer,
4771 const char *sharename)
4773 return get_a_printer_internal(print_hnd, pp_printer, level,
4777 WERROR get_a_printer_search( Printer_entry *print_hnd,
4778 NT_PRINTER_INFO_LEVEL **pp_printer,
4780 const char *sharename)
4782 return get_a_printer_internal(print_hnd, pp_printer, level,
4786 /****************************************************************************
4787 Deletes a NT_PRINTER_INFO_LEVEL struct.
4788 ****************************************************************************/
4790 uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level)
4792 NT_PRINTER_INFO_LEVEL *printer = *pp_printer;
4799 if ( printer->info_2 )
4800 free_nt_printer_info_level_2(&printer->info_2);
4804 DEBUG(0,("free_a_printer: unknown level! [%d]\n", level ));
4808 TALLOC_FREE(*pp_printer);
4813 /****************************************************************************
4814 ****************************************************************************/
4815 uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
4818 DEBUG(104,("adding a printer at level [%d]\n", level));
4819 dump_a_printer_driver(driver, level);
4823 result=add_a_printer_driver_3(driver.info_3);
4827 result=add_a_printer_driver_6(driver.info_6);
4837 /****************************************************************************
4838 ****************************************************************************/
4840 WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level,
4841 fstring drivername, const char *architecture, uint32 version)
4847 /* Sometime we just want any version of the driver */
4849 if ( version == DRIVER_ANY_VERSION ) {
4850 /* look for Win2k first and then for NT4 */
4851 result = get_a_printer_driver_3(&driver->info_3, drivername,
4854 if ( !W_ERROR_IS_OK(result) ) {
4855 result = get_a_printer_driver_3( &driver->info_3,
4856 drivername, architecture, 2 );
4859 result = get_a_printer_driver_3(&driver->info_3, drivername,
4860 architecture, version);
4869 if (W_ERROR_IS_OK(result))
4870 dump_a_printer_driver(*driver, level);
4875 /****************************************************************************
4876 ****************************************************************************/
4877 uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
4884 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
4885 if (driver.info_3 != NULL)
4887 info3=driver.info_3;
4888 SAFE_FREE(info3->dependentfiles);
4889 ZERO_STRUCTP(info3);
4899 NT_PRINTER_DRIVER_INFO_LEVEL_6 *info6;
4900 if (driver.info_6 != NULL) {
4901 info6=driver.info_6;
4902 SAFE_FREE(info6->dependentfiles);
4903 SAFE_FREE(info6->previousnames);
4904 ZERO_STRUCTP(info6);
4920 /****************************************************************************
4921 Determine whether or not a particular driver is currently assigned
4923 ****************************************************************************/
4925 bool printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3 )
4928 int n_services = lp_numservices();
4929 NT_PRINTER_INFO_LEVEL *printer = NULL;
4930 bool in_use = False;
4935 DEBUG(10,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
4937 /* loop through the printers.tdb and check for the drivername */
4939 for (snum=0; snum<n_services && !in_use; snum++) {
4940 if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
4943 if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_servicename(snum))) )
4946 if ( strequal(info_3->name, printer->info_2->drivername) )
4949 free_a_printer( &printer, 2 );
4952 DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
4955 NT_PRINTER_DRIVER_INFO_LEVEL d;
4958 DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", info_3->name));
4960 /* we can still remove the driver if there is one of
4961 "Windows NT x86" version 2 or 3 left */
4963 if ( !strequal( "Windows NT x86", info_3->environment ) ) {
4964 werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", DRIVER_ANY_VERSION );
4967 switch ( info_3->cversion ) {
4969 werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", 3 );
4972 werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", 2 );
4975 DEBUG(0,("printer_driver_in_use: ERROR! unknown driver version (%d)\n",
4977 werr = WERR_UNKNOWN_PRINTER_DRIVER;
4982 /* now check the error code */
4984 if ( W_ERROR_IS_OK(werr) ) {
4985 /* it's ok to remove the driver, we have other architctures left */
4987 free_a_printer_driver( d, 3 );
4991 /* report that the driver is not in use by default */
4997 /**********************************************************************
4998 Check to see if a ogiven file is in use by *info
4999 *********************************************************************/
5001 static bool drv_file_in_use( char* file, NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
5008 /* mz: skip files that are in the list but already deleted */
5009 if (!file || !file[0]) {
5013 if ( strequal(file, info->driverpath) )
5016 if ( strequal(file, info->datafile) )
5019 if ( strequal(file, info->configfile) )
5022 if ( strequal(file, info->helpfile) )
5025 /* see of there are any dependent files to examine */
5027 if ( !info->dependentfiles )
5030 while ( *info->dependentfiles[i] ) {
5031 if ( strequal(file, info->dependentfiles[i]) )
5040 /**********************************************************************
5041 Utility function to remove the dependent file pointed to by the
5042 input parameter from the list
5043 *********************************************************************/
5045 static void trim_dependent_file( fstring files[], int idx )
5048 /* bump everything down a slot */
5050 while( *files[idx+1] ) {
5051 fstrcpy( files[idx], files[idx+1] );
5060 /**********************************************************************
5061 Check if any of the files used by src are also used by drv
5062 *********************************************************************/
5064 static bool trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *src,
5065 NT_PRINTER_DRIVER_INFO_LEVEL_3 *drv )
5067 bool in_use = False;
5073 /* check each file. Remove it from the src structure if it overlaps */
5075 if ( drv_file_in_use(src->driverpath, drv) ) {
5077 DEBUG(10,("Removing driverfile [%s] from list\n", src->driverpath));
5078 fstrcpy( src->driverpath, "" );
5081 if ( drv_file_in_use(src->datafile, drv) ) {
5083 DEBUG(10,("Removing datafile [%s] from list\n", src->datafile));
5084 fstrcpy( src->datafile, "" );
5087 if ( drv_file_in_use(src->configfile, drv) ) {
5089 DEBUG(10,("Removing configfile [%s] from list\n", src->configfile));
5090 fstrcpy( src->configfile, "" );
5093 if ( drv_file_in_use(src->helpfile, drv) ) {
5095 DEBUG(10,("Removing helpfile [%s] from list\n", src->helpfile));
5096 fstrcpy( src->helpfile, "" );
5099 /* are there any dependentfiles to examine? */
5101 if ( !src->dependentfiles )
5104 while ( *src->dependentfiles[i] ) {
5105 if ( drv_file_in_use(src->dependentfiles[i], drv) ) {
5107 DEBUG(10,("Removing [%s] from dependent file list\n", src->dependentfiles[i]));
5108 trim_dependent_file( src->dependentfiles, i );
5116 /****************************************************************************
5117 Determine whether or not a particular driver files are currently being
5118 used by any other driver.
5120 Return value is True if any files were in use by other drivers
5121 and False otherwise.
5123 Upon return, *info has been modified to only contain the driver files
5124 which are not in use
5128 This needs to check all drivers to ensure that all files in use
5129 have been removed from *info, not just the ones in the first
5131 ****************************************************************************/
5133 bool printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
5138 fstring *list = NULL;
5139 NT_PRINTER_DRIVER_INFO_LEVEL driver;
5140 bool in_use = false;
5145 version = info->cversion;
5147 /* loop over all driver versions */
5149 DEBUG(5,("printer_driver_files_in_use: Beginning search through ntdrivers.tdb...\n"));
5151 /* get the list of drivers */
5154 ndrivers = get_ntdrivers(&list, info->environment, version);
5156 DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
5157 ndrivers, info->environment, version));
5159 /* check each driver for overlap in files */
5161 for (i=0; i<ndrivers; i++) {
5162 DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
5164 ZERO_STRUCT(driver);
5166 if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, list[i], info->environment, version)) ) {
5171 /* check if d2 uses any files from d1 */
5172 /* only if this is a different driver than the one being deleted */
5174 if ( !strequal(info->name, driver.info_3->name) ) {
5175 if ( trim_overlap_drv_files(info, driver.info_3) ) {
5176 /* mz: Do not instantly return -
5177 * we need to ensure this file isn't
5178 * also in use by other drivers. */
5183 free_a_printer_driver(driver, 3);
5188 DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
5190 driver.info_3 = info;
5192 if ( DEBUGLEVEL >= 20 )
5193 dump_a_printer_driver( driver, 3 );
5198 /****************************************************************************
5199 Actually delete the driver files. Make sure that
5200 printer_driver_files_in_use() return False before calling
5202 ****************************************************************************/
5204 static bool delete_driver_files(struct pipes_struct *rpc_pipe,
5205 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3)
5210 connection_struct *conn;
5214 fstring printdollar;
5215 int printdollar_snum;
5221 DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3->name, info_3->cversion));
5223 fstrcpy(printdollar, "print$");
5225 printdollar_snum = find_service(printdollar);
5226 if (printdollar_snum == -1) {
5230 nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
5231 lp_pathname(printdollar_snum),
5232 rpc_pipe->server_info, &oldcwd);
5233 if (!NT_STATUS_IS_OK(nt_status)) {
5234 DEBUG(0,("delete_driver_files: create_conn_struct "
5235 "returned %s\n", nt_errstr(nt_status)));
5239 if ( !CAN_WRITE(conn) ) {
5240 DEBUG(3,("delete_driver_files: Cannot delete print driver when [print$] is read-only\n"));
5244 /* now delete the files; must strip the '\print$' string from
5247 if ( *info_3->driverpath ) {
5248 if ( (s = strchr( &info_3->driverpath[1], '\\' )) != NULL ) {
5250 driver_unix_convert(conn,file,&st);
5251 DEBUG(10,("deleting driverfile [%s]\n", s));
5252 unlink_internals(conn, NULL, 0, file, False);
5256 if ( *info_3->configfile ) {
5257 if ( (s = strchr( &info_3->configfile[1], '\\' )) != NULL ) {
5259 driver_unix_convert(conn,file,&st);
5260 DEBUG(10,("deleting configfile [%s]\n", s));
5261 unlink_internals(conn, NULL, 0, file, False);
5265 if ( *info_3->datafile ) {
5266 if ( (s = strchr( &info_3->datafile[1], '\\' )) != NULL ) {
5268 driver_unix_convert(conn,file,&st);
5269 DEBUG(10,("deleting datafile [%s]\n", s));
5270 unlink_internals(conn, NULL, 0, file, False);
5274 if ( *info_3->helpfile ) {
5275 if ( (s = strchr( &info_3->helpfile[1], '\\' )) != NULL ) {
5277 driver_unix_convert(conn,file,&st);
5278 DEBUG(10,("deleting helpfile [%s]\n", s));
5279 unlink_internals(conn, NULL, 0, file, False);
5283 /* check if we are done removing files */
5285 if ( info_3->dependentfiles ) {
5286 while ( info_3->dependentfiles[i][0] ) {
5289 /* bypass the "\print$" portion of the path */
5291 if ( (p = strchr( info_3->dependentfiles[i]+1, '\\' )) != NULL ) {
5293 driver_unix_convert(conn,file,&st);
5294 DEBUG(10,("deleting dependent file [%s]\n", file));
5295 unlink_internals(conn, NULL, 0, file, False);
5307 vfs_ChDir(conn, oldcwd);
5308 conn_free_internal(conn);
5313 /****************************************************************************
5314 Remove a printer driver from the TDB. This assumes that the the driver was
5315 previously looked up.
5316 ***************************************************************************/
5318 WERROR delete_printer_driver(struct pipes_struct *rpc_pipe,
5319 NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3,
5320 uint32 version, bool delete_files )
5325 NT_PRINTER_DRIVER_INFO_LEVEL ctr;
5327 /* delete the tdb data first */
5329 arch = get_short_archi(info_3->environment);
5331 return WERR_UNKNOWN_PRINTER_DRIVER;
5333 if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
5334 arch, version, info_3->name) < 0) {
5338 DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
5339 key, delete_files ? "TRUE" : "FALSE" ));
5341 ctr.info_3 = info_3;
5342 dump_a_printer_driver( ctr, 3 );
5344 /* check if the driver actually exists for this environment */
5346 dbuf = tdb_fetch_bystring( tdb_drivers, key );
5348 DEBUG(8,("delete_printer_driver: Driver unknown [%s]\n", key));
5350 return WERR_UNKNOWN_PRINTER_DRIVER;
5353 SAFE_FREE( dbuf.dptr );
5355 /* ok... the driver exists so the delete should return success */
5357 if (tdb_delete_bystring(tdb_drivers, key) == -1) {
5358 DEBUG (0,("delete_printer_driver: fail to delete %s!\n", key));
5360 return WERR_ACCESS_DENIED;
5364 * now delete any associated files if delete_files == True
5365 * even if this part failes, we return succes because the
5366 * driver doesn not exist any more
5370 delete_driver_files(rpc_pipe, info_3);
5372 DEBUG(5,("delete_printer_driver: driver delete successful [%s]\n", key));
5378 /****************************************************************************
5379 Store a security desc for a printer.
5380 ****************************************************************************/
5382 WERROR nt_printing_setsec(const char *sharename, SEC_DESC_BUF *secdesc_ctr)
5384 SEC_DESC_BUF *new_secdesc_ctr = NULL;
5385 SEC_DESC_BUF *old_secdesc_ctr = NULL;
5386 TALLOC_CTX *mem_ctx = NULL;
5393 mem_ctx = talloc_init("nt_printing_setsec");
5394 if (mem_ctx == NULL)
5397 /* The old owner and group sids of the security descriptor are not
5398 present when new ACEs are added or removed by changing printer
5399 permissions through NT. If they are NULL in the new security
5400 descriptor then copy them over from the old one. */
5402 if (!secdesc_ctr->sd->owner_sid || !secdesc_ctr->sd->group_sid) {
5403 DOM_SID *owner_sid, *group_sid;
5404 SEC_ACL *dacl, *sacl;
5405 SEC_DESC *psd = NULL;
5408 if (!nt_printing_getsec(mem_ctx, sharename, &old_secdesc_ctr)) {
5409 status = WERR_NOMEM;
5413 /* Pick out correct owner and group sids */
5415 owner_sid = secdesc_ctr->sd->owner_sid ?
5416 secdesc_ctr->sd->owner_sid :
5417 old_secdesc_ctr->sd->owner_sid;
5419 group_sid = secdesc_ctr->sd->group_sid ?
5420 secdesc_ctr->sd->group_sid :
5421 old_secdesc_ctr->sd->group_sid;
5423 dacl = secdesc_ctr->sd->dacl ?
5424 secdesc_ctr->sd->dacl :
5425 old_secdesc_ctr->sd->dacl;
5427 sacl = secdesc_ctr->sd->sacl ?
5428 secdesc_ctr->sd->sacl :
5429 old_secdesc_ctr->sd->sacl;
5431 /* Make a deep copy of the security descriptor */
5433 psd = make_sec_desc(mem_ctx, secdesc_ctr->sd->revision, secdesc_ctr->sd->type,
5434 owner_sid, group_sid,
5440 status = WERR_NOMEM;
5444 new_secdesc_ctr = make_sec_desc_buf(mem_ctx, size, psd);
5447 if (!new_secdesc_ctr) {
5448 new_secdesc_ctr = secdesc_ctr;
5451 /* Store the security descriptor in a tdb */
5453 nt_status = marshall_sec_desc_buf(mem_ctx, new_secdesc_ctr,
5454 &blob.data, &blob.length);
5455 if (!NT_STATUS_IS_OK(nt_status)) {
5456 status = ntstatus_to_werror(nt_status);
5460 kbuf = make_printers_secdesc_tdbkey(mem_ctx, sharename );
5462 dbuf.dptr = (unsigned char *)blob.data;
5463 dbuf.dsize = blob.length;
5465 if (tdb_trans_store(tdb_printers, kbuf, dbuf, TDB_REPLACE)==0) {
5468 DEBUG(1,("Failed to store secdesc for %s\n", sharename));
5469 status = WERR_BADFUNC;
5472 /* Free malloc'ed memory */
5473 talloc_free(blob.data);
5478 talloc_destroy(mem_ctx);
5482 /****************************************************************************
5483 Construct a default security descriptor buffer for a printer.
5484 ****************************************************************************/
5486 static SEC_DESC_BUF *construct_default_printer_sdb(TALLOC_CTX *ctx)
5488 SEC_ACE ace[5]; /* max number of ace entries */
5491 SEC_ACL *psa = NULL;
5492 SEC_DESC_BUF *sdb = NULL;
5493 SEC_DESC *psd = NULL;
5497 /* Create an ACE where Everyone is allowed to print */
5499 sa = PRINTER_ACE_PRINT;
5500 init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
5501 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5503 /* Add the domain admins group if we are a DC */
5506 DOM_SID domadmins_sid;
5508 sid_copy(&domadmins_sid, get_global_sam_sid());
5509 sid_append_rid(&domadmins_sid, DOMAIN_GROUP_RID_ADMINS);
5511 sa = PRINTER_ACE_FULL_CONTROL;
5512 init_sec_ace(&ace[i++], &domadmins_sid,
5513 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
5514 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
5515 init_sec_ace(&ace[i++], &domadmins_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
5516 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5518 else if (secrets_fetch_domain_sid(lp_workgroup(), &adm_sid)) {
5519 sid_append_rid(&adm_sid, DOMAIN_USER_RID_ADMIN);
5521 sa = PRINTER_ACE_FULL_CONTROL;
5522 init_sec_ace(&ace[i++], &adm_sid,
5523 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
5524 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
5525 init_sec_ace(&ace[i++], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
5526 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5529 /* add BUILTIN\Administrators as FULL CONTROL */
5531 sa = PRINTER_ACE_FULL_CONTROL;
5532 init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
5533 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
5534 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
5535 init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
5536 SEC_ACE_TYPE_ACCESS_ALLOWED,
5537 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
5539 /* Make the security descriptor owned by the BUILTIN\Administrators */
5541 /* The ACL revision number in rpc_secdesc.h differs from the one
5542 created by NT when setting ACE entries in printer
5543 descriptors. NT4 complains about the property being edited by a
5546 if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, i, ace)) != NULL) {
5547 psd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
5548 &global_sid_Builtin_Administrators,
5549 &global_sid_Builtin_Administrators,
5550 NULL, psa, &sd_size);
5554 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
5558 sdb = make_sec_desc_buf(ctx, sd_size, psd);
5560 DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
5561 (unsigned int)sd_size));
5566 /****************************************************************************
5567 Get a security desc for a printer.
5568 ****************************************************************************/
5570 bool nt_printing_getsec(TALLOC_CTX *ctx, const char *sharename, SEC_DESC_BUF **secdesc_ctr)
5578 if (strlen(sharename) > 2 && (temp = strchr(sharename + 2, '\\'))) {
5579 sharename = temp + 1;
5582 /* Fetch security descriptor from tdb */
5584 kbuf = make_printers_secdesc_tdbkey(ctx, sharename);
5586 dbuf = tdb_fetch(tdb_printers, kbuf);
5589 status = unmarshall_sec_desc_buf(ctx, dbuf.dptr, dbuf.dsize,
5591 SAFE_FREE(dbuf.dptr);
5593 if (NT_STATUS_IS_OK(status)) {
5598 *secdesc_ctr = construct_default_printer_sdb(ctx);
5599 if (!*secdesc_ctr) {
5603 status = marshall_sec_desc_buf(ctx, *secdesc_ctr,
5604 &blob.data, &blob.length);
5605 if (NT_STATUS_IS_OK(status)) {
5606 dbuf.dptr = (unsigned char *)blob.data;
5607 dbuf.dsize = blob.length;
5608 tdb_trans_store(tdb_printers, kbuf, dbuf, TDB_REPLACE);
5609 talloc_free(blob.data);
5612 /* If security descriptor is owned by S-1-1-0 and winbindd is up,
5613 this security descriptor has been created when winbindd was
5614 down. Take ownership of security descriptor. */
5616 if (sid_equal((*secdesc_ctr)->sd->owner_sid, &global_sid_World)) {
5619 /* Change sd owner to workgroup administrator */
5621 if (secrets_fetch_domain_sid(lp_workgroup(), &owner_sid)) {
5622 SEC_DESC_BUF *new_secdesc_ctr = NULL;
5623 SEC_DESC *psd = NULL;
5628 sid_append_rid(&owner_sid, DOMAIN_USER_RID_ADMIN);
5630 psd = make_sec_desc(ctx, (*secdesc_ctr)->sd->revision, (*secdesc_ctr)->sd->type,
5632 (*secdesc_ctr)->sd->group_sid,
5633 (*secdesc_ctr)->sd->sacl,
5634 (*secdesc_ctr)->sd->dacl,
5641 new_secdesc_ctr = make_sec_desc_buf(ctx, size, psd);
5642 if (!new_secdesc_ctr) {
5646 /* Swap with other one */
5648 *secdesc_ctr = new_secdesc_ctr;
5652 nt_printing_setsec(sharename, *secdesc_ctr);
5656 if (DEBUGLEVEL >= 10) {
5657 SEC_ACL *the_acl = (*secdesc_ctr)->sd->dacl;
5660 DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
5661 sharename, the_acl->num_aces));
5663 for (i = 0; i < the_acl->num_aces; i++) {
5664 DEBUG(10, ("%s %d %d 0x%08x\n",
5665 sid_string_dbg(&the_acl->aces[i].trustee),
5666 the_acl->aces[i].type, the_acl->aces[i].flags,
5667 the_acl->aces[i].access_mask));
5676 1: level not implemented
5677 2: file doesn't exist
5678 3: can't allocate memory
5679 4: can't free memory
5680 5: non existant struct
5684 A printer and a printer driver are 2 different things.
5685 NT manages them separatelly, Samba does the same.
5686 Why ? Simply because it's easier and it makes sense !
5688 Now explanation: You have 3 printers behind your samba server,
5689 2 of them are the same make and model (laser A and B). But laser B
5690 has an 3000 sheet feeder and laser A doesn't such an option.
5691 Your third printer is an old dot-matrix model for the accounting :-).
5693 If the /usr/local/samba/lib directory (default dir), you will have
5694 5 files to describe all of this.
5696 3 files for the printers (1 by printer):
5699 NTprinter_accounting
5700 2 files for the drivers (1 for the laser and 1 for the dot matrix)
5701 NTdriver_printer model X
5702 NTdriver_printer model Y
5704 jfm: I should use this comment for the text file to explain
5705 same thing for the forms BTW.
5706 Je devrais mettre mes commentaires en francais, ca serait mieux :-)
5710 /* Convert generic access rights to printer object specific access rights.
5711 It turns out that NT4 security descriptors use generic access rights and
5712 NT5 the object specific ones. */
5714 void map_printer_permissions(SEC_DESC *sd)
5718 for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
5719 se_map_generic(&sd->dacl->aces[i].access_mask,
5720 &printer_generic_mapping);
5724 void map_job_permissions(SEC_DESC *sd)
5728 for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
5729 se_map_generic(&sd->dacl->aces[i].access_mask,
5730 &job_generic_mapping);
5735 /****************************************************************************
5736 Check a user has permissions to perform the given operation. We use the
5737 permission constants defined in include/rpc_spoolss.h to check the various
5738 actions we perform when checking printer access.
5740 PRINTER_ACCESS_ADMINISTER:
5741 print_queue_pause, print_queue_resume, update_printer_sec,
5742 update_printer, spoolss_addprinterex_level_2,
5743 _spoolss_setprinterdata
5748 JOB_ACCESS_ADMINISTER:
5749 print_job_delete, print_job_pause, print_job_resume,
5752 Try access control in the following order (for performance reasons):
5753 1) root ans SE_PRINT_OPERATOR can do anything (easy check)
5754 2) check security descriptor (bit comparisons in memory)
5755 3) "printer admins" (may result in numerous calls to winbind)
5757 ****************************************************************************/
5758 bool print_access_check(struct auth_serversupplied_info *server_info, int snum,
5761 SEC_DESC_BUF *secdesc = NULL;
5762 uint32 access_granted;
5765 TALLOC_CTX *mem_ctx = NULL;
5766 SE_PRIV se_printop = SE_PRINT_OPERATOR;
5768 /* If user is NULL then use the current_user structure */
5770 /* Always allow root or SE_PRINT_OPERATROR to do anything */
5772 if (server_info->utok.uid == 0
5773 || user_has_privileges(server_info->ptok, &se_printop ) ) {
5777 /* Get printer name */
5779 pname = PRINTERNAME(snum);
5781 if (!pname || !*pname) {
5786 /* Get printer security descriptor */
5788 if(!(mem_ctx = talloc_init("print_access_check"))) {
5793 if (!nt_printing_getsec(mem_ctx, pname, &secdesc)) {
5794 talloc_destroy(mem_ctx);
5799 if (access_type == JOB_ACCESS_ADMINISTER) {
5800 SEC_DESC_BUF *parent_secdesc = secdesc;
5802 /* Create a child security descriptor to check permissions
5803 against. This is because print jobs are child objects
5804 objects of a printer. */
5806 status = se_create_child_secdesc_buf(mem_ctx, &secdesc, parent_secdesc->sd, False);
5808 if (!NT_STATUS_IS_OK(status)) {
5809 talloc_destroy(mem_ctx);
5810 errno = map_errno_from_nt_status(status);
5814 map_job_permissions(secdesc->sd);
5816 map_printer_permissions(secdesc->sd);
5820 status = se_access_check(secdesc->sd, server_info->ptok, access_type,
5823 DEBUG(4, ("access check was %s\n", NT_STATUS_IS_OK(status) ? "SUCCESS" : "FAILURE"));
5825 /* see if we need to try the printer admin list */
5827 if ((access_granted == 0) &&
5828 (token_contains_name_in_list(uidtoname(server_info->utok.uid),
5829 NULL, NULL, server_info->ptok,
5830 lp_printer_admin(snum)))) {
5831 talloc_destroy(mem_ctx);
5835 talloc_destroy(mem_ctx);
5837 if (!NT_STATUS_IS_OK(status)) {
5841 return NT_STATUS_IS_OK(status);
5844 /****************************************************************************
5845 Check the time parameters allow a print operation.
5846 *****************************************************************************/
5848 bool print_time_access_check(const char *servicename)
5850 NT_PRINTER_INFO_LEVEL *printer = NULL;
5852 time_t now = time(NULL);
5856 if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
5859 if (printer->info_2->starttime == 0 && printer->info_2->untiltime == 0)
5863 mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
5865 if (mins >= printer->info_2->starttime && mins <= printer->info_2->untiltime)
5868 free_a_printer(&printer, 2);
5876 /****************************************************************************
5877 Fill in the servername sent in the _spoolss_open_printer_ex() call
5878 ****************************************************************************/
5880 char* get_server_name( Printer_entry *printer )
5882 return printer->servername;