?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: Added a winreg_del_driver function.
[Samba/ekacnet.git] / source3 / rpc_server / srv_spoolss_util.c
blobd6312864a8f719cede9ae13457eff7302a45c515
1 /*
2 * Unix SMB/CIFS implementation.
3 *
4 * SPOOLSS RPC Pipe server / winreg client routines
5 *
6 * Copyright (c) 2010 Andreas Schneider <asn@samba.org>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "srv_spoolss_util.h"
24 #include "../librpc/gen_ndr/srv_winreg.h"
25 #include "../librpc/gen_ndr/cli_winreg.h"
26
27 #define TOP_LEVEL_PRINT_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Print"
28 #define TOP_LEVEL_PRINT_PRINTERS_KEY TOP_LEVEL_PRINT_KEY "\\Printers"
29 #define TOP_LEVEL_CONTROL_KEY "SYSTEM\\CurrentControlSet\\Control\\Print"
30 #define TOP_LEVEL_CONTROL_FORMS_KEY TOP_LEVEL_CONTROL_KEY "\\Forms"
31
32 /* FLAGS, NAME, with, height, left, top, right, bottom */
33 static const struct spoolss_FormInfo1 builtin_forms1[] = {
34 { SPOOLSS_FORM_BUILTIN, "Letter", {0x34b5c,0x44368}, {0x0,0x0,0x34b5c,0x44368} },
35 { SPOOLSS_FORM_BUILTIN, "Letter Small", {0x34b5c,0x44368}, {0x0,0x0,0x34b5c,0x44368} },
36 { SPOOLSS_FORM_BUILTIN, "Tabloid", {0x44368,0x696b8}, {0x0,0x0,0x44368,0x696b8} },
37 { SPOOLSS_FORM_BUILTIN, "Ledger", {0x696b8,0x44368}, {0x0,0x0,0x696b8,0x44368} },
38 { SPOOLSS_FORM_BUILTIN, "Legal", {0x34b5c,0x56d10}, {0x0,0x0,0x34b5c,0x56d10} },
39 { SPOOLSS_FORM_BUILTIN, "Statement", {0x221b4,0x34b5c}, {0x0,0x0,0x221b4,0x34b5c} },
40 { SPOOLSS_FORM_BUILTIN, "Executive", {0x2cf56,0x411cc}, {0x0,0x0,0x2cf56,0x411cc} },
41 { SPOOLSS_FORM_BUILTIN, "A3", {0x48828,0x668a0}, {0x0,0x0,0x48828,0x668a0} },
42 { SPOOLSS_FORM_BUILTIN, "A4", {0x33450,0x48828}, {0x0,0x0,0x33450,0x48828} },
43 { SPOOLSS_FORM_BUILTIN, "A4 Small", {0x33450,0x48828}, {0x0,0x0,0x33450,0x48828} },
44 { SPOOLSS_FORM_BUILTIN, "A5", {0x24220,0x33450}, {0x0,0x0,0x24220,0x33450} },
45 { SPOOLSS_FORM_BUILTIN, "B4 (JIS)", {0x3ebe8,0x58de0}, {0x0,0x0,0x3ebe8,0x58de0} },
46 { SPOOLSS_FORM_BUILTIN, "B5 (JIS)", {0x2c6f0,0x3ebe8}, {0x0,0x0,0x2c6f0,0x3ebe8} },
47 { SPOOLSS_FORM_BUILTIN, "Folio", {0x34b5c,0x509d8}, {0x0,0x0,0x34b5c,0x509d8} },
48 { SPOOLSS_FORM_BUILTIN, "Quarto", {0x347d8,0x43238}, {0x0,0x0,0x347d8,0x43238} },
49 { SPOOLSS_FORM_BUILTIN, "10x14", {0x3e030,0x56d10}, {0x0,0x0,0x3e030,0x56d10} },
50 { SPOOLSS_FORM_BUILTIN, "11x17", {0x44368,0x696b8}, {0x0,0x0,0x44368,0x696b8} },
51 { SPOOLSS_FORM_BUILTIN, "Note", {0x34b5c,0x44368}, {0x0,0x0,0x34b5c,0x44368} },
52 { SPOOLSS_FORM_BUILTIN, "Envelope #9", {0x18079,0x37091}, {0x0,0x0,0x18079,0x37091} },
53 { SPOOLSS_FORM_BUILTIN, "Envelope #10", {0x19947,0x3ae94}, {0x0,0x0,0x19947,0x3ae94} },
54 { SPOOLSS_FORM_BUILTIN, "Envelope #11", {0x1be7c,0x40565}, {0x0,0x0,0x1be7c,0x40565} },
55 { SPOOLSS_FORM_BUILTIN, "Envelope #12", {0x1d74a,0x44368}, {0x0,0x0,0x1d74a,0x44368} },
56 { SPOOLSS_FORM_BUILTIN, "Envelope #14", {0x1f018,0x47504}, {0x0,0x0,0x1f018,0x47504} },
57 { SPOOLSS_FORM_BUILTIN, "C size sheet", {0x696b8,0x886d0}, {0x0,0x0,0x696b8,0x886d0} },
58 { SPOOLSS_FORM_BUILTIN, "D size sheet", {0x886d0,0xd2d70}, {0x0,0x0,0x886d0,0xd2d70} },
59 { SPOOLSS_FORM_BUILTIN, "E size sheet", {0xd2d70,0x110da0},{0x0,0x0,0xd2d70,0x110da0} },
60 { SPOOLSS_FORM_BUILTIN, "Envelope DL", {0x1adb0,0x35b60}, {0x0,0x0,0x1adb0,0x35b60} },
61 { SPOOLSS_FORM_BUILTIN, "Envelope C5", {0x278d0,0x37e88}, {0x0,0x0,0x278d0,0x37e88} },
62 { SPOOLSS_FORM_BUILTIN, "Envelope C3", {0x4f1a0,0x6fd10}, {0x0,0x0,0x4f1a0,0x6fd10} },
63 { SPOOLSS_FORM_BUILTIN, "Envelope C4", {0x37e88,0x4f1a0}, {0x0,0x0,0x37e88,0x4f1a0} },
64 { SPOOLSS_FORM_BUILTIN, "Envelope C6", {0x1bd50,0x278d0}, {0x0,0x0,0x1bd50,0x278d0} },
65 { SPOOLSS_FORM_BUILTIN, "Envelope C65", {0x1bd50,0x37e88}, {0x0,0x0,0x1bd50,0x37e88} },
66 { SPOOLSS_FORM_BUILTIN, "Envelope B4", {0x3d090,0x562e8}, {0x0,0x0,0x3d090,0x562e8} },
67 { SPOOLSS_FORM_BUILTIN, "Envelope B5", {0x2af80,0x3d090}, {0x0,0x0,0x2af80,0x3d090} },
68 { SPOOLSS_FORM_BUILTIN, "Envelope B6", {0x2af80,0x1e848}, {0x0,0x0,0x2af80,0x1e848} },
69 { SPOOLSS_FORM_BUILTIN, "Envelope", {0x1adb0,0x38270}, {0x0,0x0,0x1adb0,0x38270} },
70 { SPOOLSS_FORM_BUILTIN, "Envelope Monarch", {0x18079,0x2e824}, {0x0,0x0,0x18079,0x2e824} },
71 { SPOOLSS_FORM_BUILTIN, "6 3/4 Envelope", {0x167ab,0x284ec}, {0x0,0x0,0x167ab,0x284ec} },
72 { SPOOLSS_FORM_BUILTIN, "US Std Fanfold", {0x5c3e1,0x44368}, {0x0,0x0,0x5c3e1,0x44368} },
73 { SPOOLSS_FORM_BUILTIN, "German Std Fanfold", {0x34b5c,0x4a6a0}, {0x0,0x0,0x34b5c,0x4a6a0} },
74 { SPOOLSS_FORM_BUILTIN, "German Legal Fanfold", {0x34b5c,0x509d8}, {0x0,0x0,0x34b5c,0x509d8} },
75 { SPOOLSS_FORM_BUILTIN, "B4 (ISO)", {0x3d090,0x562e8}, {0x0,0x0,0x3d090,0x562e8} },
76 { SPOOLSS_FORM_BUILTIN, "Japanese Postcard", {0x186a0,0x24220}, {0x0,0x0,0x186a0,0x24220} },
77 { SPOOLSS_FORM_BUILTIN, "9x11", {0x37cf8,0x44368}, {0x0,0x0,0x37cf8,0x44368} },
78 { SPOOLSS_FORM_BUILTIN, "10x11", {0x3e030,0x44368}, {0x0,0x0,0x3e030,0x44368} },
79 { SPOOLSS_FORM_BUILTIN, "15x11", {0x5d048,0x44368}, {0x0,0x0,0x5d048,0x44368} },
80 { SPOOLSS_FORM_BUILTIN, "Envelope Invite", {0x35b60,0x35b60}, {0x0,0x0,0x35b60,0x35b60} },
81 { SPOOLSS_FORM_BUILTIN, "Reserved48", {0x1,0x1}, {0x0,0x0,0x1,0x1} },
82 { SPOOLSS_FORM_BUILTIN, "Reserved49", {0x1,0x1}, {0x0,0x0,0x1,0x1} },
83 { SPOOLSS_FORM_BUILTIN, "Letter Extra", {0x3ae94,0x4a6a0}, {0x0,0x0,0x3ae94,0x4a6a0} },
84 { SPOOLSS_FORM_BUILTIN, "Legal Extra", {0x3ae94,0x5d048}, {0x0,0x0,0x3ae94,0x5d048} },
85 { SPOOLSS_FORM_BUILTIN, "Tabloid Extra", {0x4a6a0,0x6f9f0}, {0x0,0x0,0x4a6a0,0x6f9f0} },
86 { SPOOLSS_FORM_BUILTIN, "A4 Extra", {0x397c2,0x4eb16}, {0x0,0x0,0x397c2,0x4eb16} },
87 { SPOOLSS_FORM_BUILTIN, "Letter Transverse", {0x34b5c,0x44368}, {0x0,0x0,0x34b5c,0x44368} },
88 { SPOOLSS_FORM_BUILTIN, "A4 Transverse", {0x33450,0x48828}, {0x0,0x0,0x33450,0x48828} },
89 { SPOOLSS_FORM_BUILTIN, "Letter Extra Transverse", {0x3ae94,0x4a6a0}, {0x0,0x0,0x3ae94,0x4a6a0} },
90 { SPOOLSS_FORM_BUILTIN, "Super A", {0x376b8,0x56ea0}, {0x0,0x0,0x376b8,0x56ea0} },
91 { SPOOLSS_FORM_BUILTIN, "Super B", {0x4a768,0x76e58}, {0x0,0x0,0x4a768,0x76e58} },
92 { SPOOLSS_FORM_BUILTIN, "Letter Plus", {0x34b5c,0x4eb16}, {0x0,0x0,0x34b5c,0x4eb16} },
93 { SPOOLSS_FORM_BUILTIN, "A4 Plus", {0x33450,0x50910}, {0x0,0x0,0x33450,0x50910} },
94 { SPOOLSS_FORM_BUILTIN, "A5 Transverse", {0x24220,0x33450}, {0x0,0x0,0x24220,0x33450} },
95 { SPOOLSS_FORM_BUILTIN, "B5 (JIS) Transverse", {0x2c6f0,0x3ebe8}, {0x0,0x0,0x2c6f0,0x3ebe8} },
96 { SPOOLSS_FORM_BUILTIN, "A3 Extra", {0x4e9d0,0x6ca48}, {0x0,0x0,0x4e9d0,0x6ca48} },
97 { SPOOLSS_FORM_BUILTIN, "A5 Extra", {0x2a7b0,0x395f8}, {0x0,0x0,0x2a7b0,0x395f8} },
98 { SPOOLSS_FORM_BUILTIN, "B5 (ISO) Extra", {0x31128,0x43620}, {0x0,0x0,0x31128,0x43620} },
99 { SPOOLSS_FORM_BUILTIN, "A2", {0x668a0,0x91050}, {0x0,0x0,0x668a0,0x91050} },
100 { SPOOLSS_FORM_BUILTIN, "A3 Transverse", {0x48828,0x668a0}, {0x0,0x0,0x48828,0x668a0} },
101 { SPOOLSS_FORM_BUILTIN, "A3 Extra Transverse", {0x4e9d0,0x6ca48}, {0x0,0x0,0x4e9d0,0x6ca48} },
102 { SPOOLSS_FORM_BUILTIN, "Japanese Double Postcard", {0x30d40,0x24220}, {0x0,0x0,0x30d40,0x24220} },
103 { SPOOLSS_FORM_BUILTIN, "A6", {0x19a28,0x24220}, {0x0,0x0,0x19a28,0x24220} },
104 { SPOOLSS_FORM_BUILTIN, "Japanese Envelope Kaku #2", {0x3a980,0x510e0}, {0x0,0x0,0x3a980,0x510e0} },
105 { SPOOLSS_FORM_BUILTIN, "Japanese Envelope Kaku #3", {0x34bc0,0x43a08}, {0x0,0x0,0x34bc0,0x43a08} },
106 { SPOOLSS_FORM_BUILTIN, "Japanese Envelope Chou #3", {0x1d4c0,0x395f8}, {0x0,0x0,0x1d4c0,0x395f8} },
107 { SPOOLSS_FORM_BUILTIN, "Japanese Envelope Chou #4", {0x15f90,0x320c8}, {0x0,0x0,0x15f90,0x320c8} },
108 { SPOOLSS_FORM_BUILTIN, "Letter Rotated", {0x44368,0x34b5c}, {0x0,0x0,0x44368,0x34b5c} },
109 { SPOOLSS_FORM_BUILTIN, "A3 Rotated", {0x668a0,0x48828}, {0x0,0x0,0x668a0,0x48828} },
110 { SPOOLSS_FORM_BUILTIN, "A4 Rotated", {0x48828,0x33450}, {0x0,0x0,0x48828,0x33450} },
111 { SPOOLSS_FORM_BUILTIN, "A5 Rotated", {0x33450,0x24220}, {0x0,0x0,0x33450,0x24220} },
112 { SPOOLSS_FORM_BUILTIN, "B4 (JIS) Rotated", {0x58de0,0x3ebe8}, {0x0,0x0,0x58de0,0x3ebe8} },
113 { SPOOLSS_FORM_BUILTIN, "B5 (JIS) Rotated", {0x3ebe8,0x2c6f0}, {0x0,0x0,0x3ebe8,0x2c6f0} },
114 { SPOOLSS_FORM_BUILTIN, "Japanese Postcard Rotated", {0x24220,0x186a0}, {0x0,0x0,0x24220,0x186a0} },
115 { SPOOLSS_FORM_BUILTIN, "Double Japan Postcard Rotated", {0x24220,0x30d40}, {0x0,0x0,0x24220,0x30d40} },
116 { SPOOLSS_FORM_BUILTIN, "A6 Rotated", {0x24220,0x19a28}, {0x0,0x0,0x24220,0x19a28} },
117 { SPOOLSS_FORM_BUILTIN, "Japan Envelope Kaku #2 Rotated", {0x510e0,0x3a980}, {0x0,0x0,0x510e0,0x3a980} },
118 { SPOOLSS_FORM_BUILTIN, "Japan Envelope Kaku #3 Rotated", {0x43a08,0x34bc0}, {0x0,0x0,0x43a08,0x34bc0} },
119 { SPOOLSS_FORM_BUILTIN, "Japan Envelope Chou #3 Rotated", {0x395f8,0x1d4c0}, {0x0,0x0,0x395f8,0x1d4c0} },
120 { SPOOLSS_FORM_BUILTIN, "Japan Envelope Chou #4 Rotated", {0x320c8,0x15f90}, {0x0,0x0,0x320c8,0x15f90} },
121 { SPOOLSS_FORM_BUILTIN, "B6 (JIS)", {0x1f400,0x2c6f0}, {0x0,0x0,0x1f400,0x2c6f0} },
122 { SPOOLSS_FORM_BUILTIN, "B6 (JIS) Rotated", {0x2c6f0,0x1f400}, {0x0,0x0,0x2c6f0,0x1f400} },
123 { SPOOLSS_FORM_BUILTIN, "12x11", {0x4a724,0x443e1}, {0x0,0x0,0x4a724,0x443e1} },
124 { SPOOLSS_FORM_BUILTIN, "Japan Envelope You #4", {0x19a28,0x395f8}, {0x0,0x0,0x19a28,0x395f8} },
125 { SPOOLSS_FORM_BUILTIN, "Japan Envelope You #4 Rotated", {0x395f8,0x19a28}, {0x0,0x0,0x395f8,0x19a28} },
126 { SPOOLSS_FORM_BUILTIN, "PRC 16K", {0x2de60,0x3f7a0}, {0x0,0x0,0x2de60,0x3f7a0} },
127 { SPOOLSS_FORM_BUILTIN, "PRC 32K", {0x1fbd0,0x2cec0}, {0x0,0x0,0x1fbd0,0x2cec0} },
128 { SPOOLSS_FORM_BUILTIN, "PRC 32K(Big)", {0x222e0,0x318f8}, {0x0,0x0,0x222e0,0x318f8} },
129 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #1", {0x18e70,0x28488}, {0x0,0x0,0x18e70,0x28488} },
130 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #2", {0x18e70,0x2af80}, {0x0,0x0,0x18e70,0x2af80} },
131 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #3", {0x1e848,0x2af80}, {0x0,0x0,0x1e848,0x2af80} },
132 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #4", {0x1adb0,0x32c80}, {0x0,0x0,0x1adb0,0x32c80} },
133 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #5", {0x1adb0,0x35b60}, {0x0,0x0,0x1adb0,0x35b60} },
134 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #6", {0x1d4c0,0x38270}, {0x0,0x0,0x1d4c0,0x38270} },
135 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #7", {0x27100,0x38270}, {0x0,0x0,0x27100,0x38270} },
136 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #8", {0x1d4c0,0x4b708}, {0x0,0x0,0x1d4c0,0x4b708} },
137 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #9", {0x37e88,0x4f1a0}, {0x0,0x0,0x37e88,0x4f1a0} },
138 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #10", {0x4f1a0,0x6fd10}, {0x0,0x0,0x4f1a0,0x6fd10} },
139 { SPOOLSS_FORM_BUILTIN, "PRC 16K Rotated", {0x3f7a0,0x2de60}, {0x0,0x0,0x3f7a0,0x2de60} },
140 { SPOOLSS_FORM_BUILTIN, "PRC 32K Rotated", {0x2cec0,0x1fbd0}, {0x0,0x0,0x2cec0,0x1fbd0} },
141 { SPOOLSS_FORM_BUILTIN, "PRC 32K(Big) Rotated", {0x318f8,0x222e0}, {0x0,0x0,0x318f8,0x222e0} },
142 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #1 Rotated", {0x28488,0x18e70}, {0x0,0x0,0x28488,0x18e70} },
143 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #2 Rotated", {0x2af80,0x18e70}, {0x0,0x0,0x2af80,0x18e70} },
144 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #3 Rotated", {0x2af80,0x1e848}, {0x0,0x0,0x2af80,0x1e848} },
145 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #4 Rotated", {0x32c80,0x1adb0}, {0x0,0x0,0x32c80,0x1adb0} },
146 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #5 Rotated", {0x35b60,0x1adb0}, {0x0,0x0,0x35b60,0x1adb0} },
147 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #6 Rotated", {0x38270,0x1d4c0}, {0x0,0x0,0x38270,0x1d4c0} },
148 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #7 Rotated", {0x38270,0x27100}, {0x0,0x0,0x38270,0x27100} },
149 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #8 Rotated", {0x4b708,0x1d4c0}, {0x0,0x0,0x4b708,0x1d4c0} },
150 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #9 Rotated", {0x4f1a0,0x37e88}, {0x0,0x0,0x4f1a0,0x37e88} },
151 { SPOOLSS_FORM_BUILTIN, "PRC Envelope #10 Rotated", {0x6fd10,0x4f1a0}, {0x0,0x0,0x6fd10,0x4f1a0} }
152 };
153
154 /********************************************************************
155 static helper functions
156 ********************************************************************/
157
158 /****************************************************************************
159 Update the changeid time.
160 ****************************************************************************/
161 /**
162 * @internal
163 *
164 * @brief Update the ChangeID time of a printer.
165 *
166 * This is SO NASTY as some drivers need this to change, others need it
167 * static. This value will change every second, and I must hope that this
168 * is enough..... DON'T CHANGE THIS CODE WITHOUT A TEST MATRIX THE SIZE OF
169 * UTAH ! JRA.
170 *
171 * @return The ChangeID.
172 */
173 static uint32_t winreg_printer_rev_changeid(void)
174 {
175 struct timeval tv;
176
177 get_process_uptime(&tv);
178
179 #if 1 /* JERRY */
180 /* Return changeid as msec since spooler restart */
181 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
182 #else
183 /*
184 * This setting seems to work well but is too untested
185 * to replace the above calculation. Left in for experiementation
186 * of the reader --jerry (Tue Mar 12 09:15:05 CST 2002)
187 */
188 return tv.tv_sec * 10 + tv.tv_usec / 100000;
189 #endif
190 }
191
192 /**
193 * @internal
194 *
195 * @brief Connect to the interal winreg server and open the given printer key.
196 *
197 * The function will create the needed subkeys if they don't exist.
198 *
199 * @param[in] mem_ctx The memory context to use.
200 *
201 * @param[in] server_info The supplied server info.
202 *
203 * @param[out] winreg_pipe A pointer for the winreg rpc client pipe.
204 *
205 * @param[in] path The path to the key to open.
206 *
207 * @param[in] key The key to open.
208 *
209 * @param[in] create_key Set to true if the key should be created if it
210 * doesn't exist.
211 *
212 * @param[in] access_mask The access mask to open the key.
213 *
214 * @param[out] hive_handle A policy handle for the opened hive.
215 *
216 * @param[out] key_handle A policy handle for the opened key.
217 *
218 * @return WERR_OK on success, the corresponding DOS error
219 * code if something gone wrong.
220 */
221 static WERROR winreg_printer_openkey(TALLOC_CTX *mem_ctx,
222 struct auth_serversupplied_info *server_info,
223 struct rpc_pipe_client **winreg_pipe,
224 const char *path,
225 const char *key,
226 bool create_key,
227 uint32_t access_mask,
228 struct policy_handle *hive_handle,
229 struct policy_handle *key_handle)
230 {
231 struct rpc_pipe_client *pipe_handle;
232 struct winreg_String wkey, wkeyclass;
233 char *keyname;
234 NTSTATUS status;
235 WERROR result = WERR_OK;
236
237 /* create winreg connection */
238 status = rpc_pipe_open_internal(mem_ctx,
239 &ndr_table_winreg.syntax_id,
240 rpc_winreg_dispatch,
241 server_info,
242 &pipe_handle);
243 if (!NT_STATUS_IS_OK(status)) {
244 DEBUG(0, ("winreg_printer_openkey: Could not connect to winreg_pipe: %s\n",
245 nt_errstr(status)));
246 return ntstatus_to_werror(status);
247 }
248
249 status = rpccli_winreg_OpenHKLM(pipe_handle,
250 mem_ctx,
251 NULL,
252 access_mask,
253 hive_handle,
254 &result);
255 if (!NT_STATUS_IS_OK(status)) {
256 DEBUG(0, ("winreg_printer_openkey: Could not open HKLM hive: %s\n",
257 nt_errstr(status)));
258 talloc_free(pipe_handle);
259 if (!W_ERROR_IS_OK(result)) {
260 return result;
261 }
262 return ntstatus_to_werror(status);
263 }
264
265 if (key && *key) {
266 keyname = talloc_asprintf(mem_ctx, "%s\\%s", path, key);
267 } else {
268 keyname = talloc_strdup(mem_ctx, path);
269 }
270 if (keyname == NULL) {
271 talloc_free(pipe_handle);
272 return WERR_NOMEM;
273 }
274
275 ZERO_STRUCT(wkey);
276 wkey.name = keyname;
277
278 if (create_key) {
279 enum winreg_CreateAction action = REG_ACTION_NONE;
280
281 ZERO_STRUCT(wkeyclass);
282 wkeyclass.name = "";
283
284 status = rpccli_winreg_CreateKey(pipe_handle,
285 mem_ctx,
286 hive_handle,
287 wkey,
288 wkeyclass,
289 0,
290 access_mask,
291 NULL,
292 key_handle,
293 &action,
294 &result);
295 switch (action) {
296 case REG_ACTION_NONE:
297 DEBUG(8, ("winreg_printer_openkey:createkey did nothing -- huh?\n"));
298 break;
299 case REG_CREATED_NEW_KEY:
300 DEBUG(8, ("winreg_printer_openkey: createkey created %s\n", keyname));
301 break;
302 case REG_OPENED_EXISTING_KEY:
303 DEBUG(8, ("winreg_printer_openkey: createkey opened existing %s\n", keyname));
304 break;
305 }
306 } else {
307 status = rpccli_winreg_OpenKey(pipe_handle,
308 mem_ctx,
309 hive_handle,
310 wkey,
311 0,
312 access_mask,
313 key_handle,
314 &result);
315 }
316 if (!NT_STATUS_IS_OK(status)) {
317 talloc_free(pipe_handle);
318 if (!W_ERROR_IS_OK(result)) {
319 return result;
320 }
321 return ntstatus_to_werror(status);
322 }
323
324 *winreg_pipe = pipe_handle;
325
326 return WERR_OK;
327 }
328
329 /**
330 * @brief Create the registry keyname for the given printer.
331 *
332 * @param[in] mem_ctx The memory context to use.
333 *
334 * @param[in] printer The name of the printer to get the registry key.
335 *
336 * @return The registry key or NULL on error.
337 */
338 static char *winreg_printer_data_keyname(TALLOC_CTX *mem_ctx, const char *printer) {
339 return talloc_asprintf(mem_ctx, "%s\\%s", TOP_LEVEL_PRINT_PRINTERS_KEY, printer);
340 }
341
342 /**
343 * @internal
344 *
345 * @brief Enumerate values of an opened key handle and retrieve the data.
346 *
347 * @param[in] mem_ctx The memory context to use.
348 *
349 * @param[in] pipe_handle The pipe handle for the rpc connection.
350 *
351 * @param[in] key_hnd The opened key handle.
352 *
353 * @param[out] pnum_values A pointer to store he number of values found.
354 *
355 * @param[out] pnum_values A pointer to store the number of values we found.
356 *
357 * @return WERR_OK on success, the corresponding DOS error
358 * code if something gone wrong.
359 */
360 static WERROR winreg_printer_enumvalues(TALLOC_CTX *mem_ctx,
361 struct rpc_pipe_client *pipe_handle,
362 struct policy_handle *key_hnd,
363 uint32_t *pnum_values,
364 struct spoolss_PrinterEnumValues **penum_values)
365 {
366 TALLOC_CTX *tmp_ctx;
367 uint32_t num_subkeys, max_subkeylen, max_classlen;
368 uint32_t num_values, max_valnamelen, max_valbufsize;
369 uint32_t secdescsize;
370 uint32_t i;
371 NTTIME last_changed_time;
372 struct winreg_String classname;
373
374 struct spoolss_PrinterEnumValues *enum_values;
375
376 WERROR result = WERR_OK;
377 NTSTATUS status;
378
379 tmp_ctx = talloc_new(mem_ctx);
380 if (tmp_ctx == NULL) {
381 return WERR_NOMEM;
382 }
383
384 ZERO_STRUCT(classname);
385
386 status = rpccli_winreg_QueryInfoKey(pipe_handle,
387 tmp_ctx,
388 key_hnd,
389 &classname,
390 &num_subkeys,
391 &max_subkeylen,
392 &max_classlen,
393 &num_values,
394 &max_valnamelen,
395 &max_valbufsize,
396 &secdescsize,
397 &last_changed_time,
398 &result);
399 if (!NT_STATUS_IS_OK(status)) {
400 DEBUG(0, ("winreg_printer_enumvalues: Could not query info: %s\n",
401 nt_errstr(status)));
402 if (!W_ERROR_IS_OK(result)) {
403 goto error;
404 }
405 result = ntstatus_to_werror(status);
406 goto error;
407 }
408
409 if (num_values == 0) {
410 *pnum_values = 0;
411 TALLOC_FREE(tmp_ctx);
412 return WERR_OK;
413 }
414
415 enum_values = TALLOC_ARRAY(tmp_ctx, struct spoolss_PrinterEnumValues, num_values);
416 if (enum_values == NULL) {
417 result = WERR_NOMEM;
418 goto error;
419 }
420
421 for (i = 0; i < num_values; i++) {
422 struct spoolss_PrinterEnumValues val;
423 struct winreg_ValNameBuf name_buf;
424 enum winreg_Type type = REG_NONE;
425 uint8_t *data = NULL;
426 uint32_t data_size;
427 uint32_t length;
428 char n = '\0';;
429
430 name_buf.name = &n;
431 name_buf.size = max_valnamelen + 2;
432 name_buf.length = 0;
433
434 data_size = max_valbufsize;
435 data = (uint8_t *) TALLOC(tmp_ctx, data_size);
436 length = 0;
437
438 status = rpccli_winreg_EnumValue(pipe_handle,
439 tmp_ctx,
440 key_hnd,
441 i,
442 &name_buf,
443 &type,
444 data,
445 &data_size,
446 &length,
447 &result);
448 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
449 result = WERR_OK;
450 status = NT_STATUS_OK;
451 break;
452 }
453
454 if (!NT_STATUS_IS_OK(status)) {
455 DEBUG(0, ("winreg_printer_enumvalues: Could not enumerate values: %s\n",
456 nt_errstr(status)));
457 if (!W_ERROR_IS_OK(result)) {
458 goto error;
459 }
460 result = ntstatus_to_werror(status);
461 goto error;
462 }
463
464 if (name_buf.name == NULL) {
465 result = WERR_INVALID_PARAMETER;
466 goto error;
467 }
468
469 val.value_name = talloc_strdup(enum_values, name_buf.name);
470 if (val.value_name == NULL) {
471 result = WERR_NOMEM;
472 goto error;
473 }
474 val.value_name_len = strlen_m_term(val.value_name) * 2;
475
476 val.type = type;
477 val.data_length = data_size;
478 val.data = NULL;
479 if (val.data_length) {
480 val.data = talloc(enum_values, DATA_BLOB);
481 if (val.data == NULL) {
482 result = WERR_NOMEM;
483 goto error;
484 }
485 *val.data = data_blob_talloc(enum_values, data, data_size);
486 }
487
488 enum_values[i] = val;
489 }
490
491 *pnum_values = num_values;
492 if (penum_values) {
493 *penum_values = talloc_move(mem_ctx, &enum_values);
494 }
495
496 result = WERR_OK;
497
498 error:
499 TALLOC_FREE(tmp_ctx);
500 return result;
501 }
502
503 /**
504 * @internal
505 *
506 * @brief Enumerate subkeys of an opened key handle and get the names.
507 *
508 * @param[in] mem_ctx The memory context to use.
509 *
510 * @param[in] pipe_handle The pipe handle for the rpc connection.
511 *
512 * @param[in] key_hnd The opened key handle.
513 *
514 * @param[in] pnum_subkeys A pointer to store the number of found subkeys.
515 *
516 * @param[in] psubkeys A pointer to an array to store the found names of
517 * subkeys.
518 *
519 * @return WERR_OK on success, the corresponding DOS error
520 * code if something gone wrong.
521 */
522 static WERROR winreg_printer_enumkeys(TALLOC_CTX *mem_ctx,
523 struct rpc_pipe_client *pipe_handle,
524 struct policy_handle *key_hnd,
525 uint32_t *pnum_subkeys,
526 const char ***psubkeys)
527 {
528 TALLOC_CTX *tmp_ctx;
529 const char **subkeys;
530 uint32_t num_subkeys, max_subkeylen, max_classlen;
531 uint32_t num_values, max_valnamelen, max_valbufsize;
532 uint32_t i;
533 NTTIME last_changed_time;
534 uint32_t secdescsize;
535 struct winreg_String classname;
536 WERROR result = WERR_OK;
537 NTSTATUS status;
538
539 tmp_ctx = talloc_new(mem_ctx);
540 if (tmp_ctx == NULL) {
541 return WERR_NOMEM;
542 }
543
544 ZERO_STRUCT(classname);
545
546 status = rpccli_winreg_QueryInfoKey(pipe_handle,
547 tmp_ctx,
548 key_hnd,
549 &classname,
550 &num_subkeys,
551 &max_subkeylen,
552 &max_classlen,
553 &num_values,
554 &max_valnamelen,
555 &max_valbufsize,
556 &secdescsize,
557 &last_changed_time,
558 &result);
559 if (!NT_STATUS_IS_OK(status)) {
560 DEBUG(0, ("winreg_printer_enumkeys: Could not query info: %s\n",
561 nt_errstr(status)));
562 if (!W_ERROR_IS_OK(result)) {
563 goto error;
564 }
565 result = ntstatus_to_werror(status);
566 goto error;
567 }
568
569 subkeys = talloc_zero_array(tmp_ctx, const char *, num_subkeys + 2);
570 if (subkeys == NULL) {
571 result = WERR_NOMEM;
572 goto error;
573 }
574
575 if (num_subkeys == 0) {
576 subkeys[0] = talloc_strdup(subkeys, "");
577 if (subkeys[0] == NULL) {
578 result = WERR_NOMEM;
579 goto error;
580 }
581 *pnum_subkeys = 0;
582 if (psubkeys) {
583 *psubkeys = talloc_move(mem_ctx, &subkeys);
584 }
585
586 TALLOC_FREE(tmp_ctx);
587 return WERR_OK;
588 }
589
590 for (i = 0; i < num_subkeys; i++) {
591 char c = '\0';
592 char n = '\0';
593 char *name = NULL;
594 struct winreg_StringBuf class_buf;
595 struct winreg_StringBuf name_buf;
596 NTTIME modtime;
597
598 class_buf.name = &c;
599 class_buf.size = max_classlen + 2;
600 class_buf.length = 0;
601
602 name_buf.name = &n;
603 name_buf.size = max_subkeylen + 2;
604 name_buf.length = 0;
605
606 ZERO_STRUCT(modtime);
607
608 status = rpccli_winreg_EnumKey(pipe_handle,
609 tmp_ctx,
610 key_hnd,
611 i,
612 &name_buf,
613 &class_buf,
614 &modtime,
615 &result);
616 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
617 result = WERR_OK;
618 status = NT_STATUS_OK;
619 break;
620 }
621
622 if (!NT_STATUS_IS_OK(status)) {
623 DEBUG(0, ("winreg_printer_enumkeys: Could not enumerate keys: %s\n",
624 nt_errstr(status)));
625 if (!W_ERROR_IS_OK(result)) {
626 goto error;
627 }
628 result = ntstatus_to_werror(status);
629 goto error;
630 }
631
632 if (name_buf.name == NULL) {
633 result = WERR_INVALID_PARAMETER;
634 goto error;
635 }
636
637 name = talloc_strdup(subkeys, name_buf.name);
638 if (name == NULL) {
639 result = WERR_NOMEM;
640 goto error;
641 }
642
643 subkeys[i] = name;
644 }
645
646 *pnum_subkeys = num_subkeys;
647 if (psubkeys) {
648 *psubkeys = talloc_move(mem_ctx, &subkeys);
649 }
650
651 error:
652 TALLOC_FREE(tmp_ctx);
653 return result;
654 }
655
656 /**
657 * @internal
658 *
659 * @brief A function to delete a key and its subkeys recurively.
660 *
661 * @param[in] mem_ctx The memory context to use.
662 *
663 * @param[in] pipe_handle The pipe handle for the rpc connection.
664 *
665 * @param[in] hive_handle A opened hive handle to the key.
666 *
667 * @param[in] access_mask The access mask to access the key.
668 *
669 * @param[in] key The key to delete
670 *
671 * @return WERR_OK on success, the corresponding DOS error
672 * code if something gone wrong.
673 */
674 static WERROR winreg_printer_delete_subkeys(TALLOC_CTX *mem_ctx,
675 struct rpc_pipe_client *pipe_handle,
676 struct policy_handle *hive_handle,
677 uint32_t access_mask,
678 const char *key)
679 {
680 const char **subkeys = NULL;
681 uint32_t num_subkeys = 0;
682 struct policy_handle key_hnd;
683 struct winreg_String wkey;
684 WERROR result = WERR_OK;
685 NTSTATUS status;
686 uint32_t i;
687
688 ZERO_STRUCT(key_hnd);
689 wkey.name = key;
690
691 DEBUG(2, ("winreg_printer_delete_subkeys: delete key %s\n", key));
692 /* open the key */
693 status = rpccli_winreg_OpenKey(pipe_handle,
694 mem_ctx,
695 hive_handle,
696 wkey,
697 0,
698 access_mask,
699 &key_hnd,
700 &result);
701 if (!NT_STATUS_IS_OK(status)) {
702 DEBUG(0, ("winreg_printer_delete_subkeys: Could not open key %s: %s\n",
703 wkey.name, nt_errstr(status)));
704 if (!W_ERROR_IS_OK(result)) {
705 return result;
706 }
707 return ntstatus_to_werror(status);
708 }
709
710 result = winreg_printer_enumkeys(mem_ctx,
711 pipe_handle,
712 &key_hnd,
713 &num_subkeys,
714 &subkeys);
715 if (!W_ERROR_IS_OK(result)) {
716 goto done;
717 }
718
719 for (i = 0; i < num_subkeys; i++) {
720 /* create key + subkey */
721 char *subkey = talloc_asprintf(mem_ctx, "%s\\%s", key, subkeys[i]);
722 if (subkey == NULL) {
723 goto done;
724 }
725
726 DEBUG(2, ("winreg_printer_delete_subkeys: delete subkey %s\n", subkey));
727 result = winreg_printer_delete_subkeys(mem_ctx,
728 pipe_handle,
729 hive_handle,
730 access_mask,
731 subkey);
732 if (!W_ERROR_IS_OK(result)) {
733 goto done;
734 }
735 }
736
737 if (is_valid_policy_hnd(&key_hnd)) {
738 rpccli_winreg_CloseKey(pipe_handle, mem_ctx, &key_hnd, NULL);
739 }
740
741 wkey.name = key;
742
743 status = rpccli_winreg_DeleteKey(pipe_handle,
744 mem_ctx,
745 hive_handle,
746 wkey,
747 &result);
748
749 done:
750 if (is_valid_policy_hnd(&key_hnd)) {
751 rpccli_winreg_CloseKey(pipe_handle, mem_ctx, &key_hnd, NULL);
752 }
753
754 return result;
755 }
756
757 static WERROR winreg_printer_write_sz(TALLOC_CTX *mem_ctx,
758 struct rpc_pipe_client *pipe_handle,
759 struct policy_handle *key_handle,
760 const char *value,
761 const char *data)
762 {
763 struct winreg_String wvalue;
764 DATA_BLOB blob;
765 WERROR result = WERR_OK;
766 NTSTATUS status;
767
768 wvalue.name = value;
769 if (data == NULL) {
770 blob = data_blob_string_const("");
771 } else {
772 if (!push_reg_sz(mem_ctx, NULL, &blob, data)) {
773 DEBUG(0, ("winreg_printer_write_sz: Could not marshall string %s for %s\n",
774 data, wvalue.name));
775 return WERR_NOMEM;
776 }
777 }
778 status = rpccli_winreg_SetValue(pipe_handle,
779 mem_ctx,
780 key_handle,
781 wvalue,
782 REG_SZ,
783 blob.data,
784 blob.length,
785 &result);
786 if (!NT_STATUS_IS_OK(status)) {
787 DEBUG(0, ("winreg_printer_write_sz: Could not set value %s: %s\n",
788 wvalue.name, win_errstr(result)));
789 if (!W_ERROR_IS_OK(result)) {
790 result = ntstatus_to_werror(status);
791 }
792 }
793
794 return result;
795 }
796
797 static WERROR winreg_printer_write_dword(TALLOC_CTX *mem_ctx,
798 struct rpc_pipe_client *pipe_handle,
799 struct policy_handle *key_handle,
800 const char *value,
801 uint32_t data)
802 {
803 struct winreg_String wvalue;
804 DATA_BLOB blob;
805 WERROR result = WERR_OK;
806 NTSTATUS status;
807
808 wvalue.name = value;
809 blob = data_blob_talloc(mem_ctx, NULL, 4);
810 SIVAL(blob.data, 0, data);
811
812 status = rpccli_winreg_SetValue(pipe_handle,
813 mem_ctx,
814 key_handle,
815 wvalue,
816 REG_DWORD,
817 blob.data,
818 blob.length,
819 &result);
820 if (!NT_STATUS_IS_OK(status)) {
821 DEBUG(0, ("winreg_printer_write_dword: Could not set value %s: %s\n",
822 wvalue.name, win_errstr(result)));
823 if (!W_ERROR_IS_OK(result)) {
824 result = ntstatus_to_werror(status);
825 }
826 }
827
828 return result;
829 }
830
831 static WERROR winreg_printer_write_binary(TALLOC_CTX *mem_ctx,
832 struct rpc_pipe_client *pipe_handle,
833 struct policy_handle *key_handle,
834 const char *value,
835 DATA_BLOB blob)
836 {
837 struct winreg_String wvalue;
838 WERROR result = WERR_OK;
839 NTSTATUS status;
840
841 wvalue.name = value;
842 status = rpccli_winreg_SetValue(pipe_handle,
843 mem_ctx,
844 key_handle,
845 wvalue,
846 REG_BINARY,
847 blob.data,
848 blob.length,
849 &result);
850 if (!NT_STATUS_IS_OK(status)) {
851 DEBUG(0, ("winreg_printer_write_binary: Could not set value %s: %s\n",
852 wvalue.name, win_errstr(result)));
853 if (!W_ERROR_IS_OK(result)) {
854 result = ntstatus_to_werror(status);
855 }
856 }
857
858 return result;
859 }
860
861 static WERROR winreg_printer_query_dword(TALLOC_CTX *mem_ctx,
862 struct rpc_pipe_client *pipe_handle,
863 struct policy_handle *key_handle,
864 const char *value,
865 uint32_t *data)
866 {
867 struct winreg_String wvalue;
868 enum winreg_Type type;
869 WERROR result = WERR_OK;
870 uint32_t value_len = 0;
871 NTSTATUS status;
872 DATA_BLOB blob;
873
874 wvalue.name = value;
875 status = rpccli_winreg_QueryValue(pipe_handle,
876 mem_ctx,
877 key_handle,
878 &wvalue,
879 &type,
880 NULL,
881 (uint32_t *) &blob.length,
882 &value_len,
883 &result);
884 if (!NT_STATUS_IS_OK(status)) {
885 DEBUG(0, ("winreg_printer_query_dword: Could not query value %s: %s\n",
886 wvalue.name, nt_errstr(status)));
887 if (!W_ERROR_IS_OK(result)) {
888 goto done;
889 }
890 result = ntstatus_to_werror(status);
891 goto done;
892 }
893
894 if (type != REG_DWORD) {
895 result = WERR_INVALID_DATATYPE;
896 goto done;
897 }
898
899 if (blob.length != 4) {
900 result = WERR_INVALID_DATA;
901 goto done;
902 }
903
904 blob.data = (uint8_t *) TALLOC(mem_ctx, blob.length);
905 if (blob.data == NULL) {
906 result = WERR_NOMEM;
907 goto done;
908 }
909 value_len = 0;
910
911 status = rpccli_winreg_QueryValue(pipe_handle,
912 mem_ctx,
913 key_handle,
914 &wvalue,
915 &type,
916 blob.data,
917 (uint32_t *) &blob.length,
918 &value_len,
919 &result);
920 if (!NT_STATUS_IS_OK(status)) {
921 DEBUG(0, ("winreg_printer_query_dword: Could not query value %s: %s\n",
922 wvalue.name, nt_errstr(status)));
923 if (!W_ERROR_IS_OK(result)) {
924 result = ntstatus_to_werror(status);
925 }
926 goto done;
927 }
928
929 if (data) {
930 *data = IVAL(blob.data, 0);
931 }
932 done:
933 return result;
934 }
935
936 static WERROR winreg_printer_write_multi_sz(TALLOC_CTX *mem_ctx,
937 struct rpc_pipe_client *pipe_handle,
938 struct policy_handle *key_handle,
939 const char *value,
940 const char **data)
941 {
942 struct winreg_String wvalue;
943 DATA_BLOB blob;
944 WERROR result = WERR_OK;
945 NTSTATUS status;
946
947 wvalue.name = value;
948 if (!push_reg_multi_sz(mem_ctx, NULL, &blob, data)) {
949 return WERR_NOMEM;
950 }
951 status = rpccli_winreg_SetValue(pipe_handle,
952 mem_ctx,
953 key_handle,
954 wvalue,
955 REG_MULTI_SZ,
956 blob.data,
957 blob.length,
958 &result);
959 if (!NT_STATUS_IS_OK(status)) {
960 DEBUG(0, ("winreg_printer_write_multi_sz: Could not set value %s: %s\n",
961 wvalue.name, win_errstr(result)));
962 if (!W_ERROR_IS_OK(result)) {
963 result = ntstatus_to_werror(status);
964 }
965 }
966
967 return result;
968 }
969
970 static WERROR winreg_printer_opendriver(TALLOC_CTX *mem_ctx,
971 struct auth_serversupplied_info *server_info,
972 const char *drivername,
973 const char *architecture,
974 uint32_t version,
975 uint32_t access_mask,
976 bool create,
977 struct rpc_pipe_client **winreg_pipe,
978 struct policy_handle *hive_hnd,
979 struct policy_handle *key_hnd)
980 {
981 WERROR result;
982 char *key_name;
983
984 key_name = talloc_asprintf(mem_ctx, "%s\\Environments\\%s\\Drivers\\Version-%u",
985 TOP_LEVEL_CONTROL_KEY,
986 architecture, version);
987 if (!key_name) {
988 return WERR_NOMEM;
989 }
990
991 result = winreg_printer_openkey(mem_ctx,
992 server_info,
993 winreg_pipe,
994 key_name,
995 drivername,
996 create,
997 access_mask,
998 hive_hnd,
999 key_hnd);
1000 return result;
1001 }
1002
1003 static WERROR winreg_enumval_to_dword(TALLOC_CTX *mem_ctx,
1004 struct spoolss_PrinterEnumValues *v,
1005 const char *valuename, uint32_t *dw)
1006 {
1007 /* just return if it is not the one we are looking for */
1008 if (strcmp(valuename, v->value_name) != 0) {
1009 return WERR_NOT_FOUND;
1010 }
1011
1012 if (v->type != REG_DWORD) {
1013 return WERR_INVALID_DATATYPE;
1014 }
1015
1016 *dw = IVAL(v->data->data, 0);
1017 return WERR_OK;
1018 }
1019
1020 static WERROR winreg_enumval_to_sz(TALLOC_CTX *mem_ctx,
1021 struct spoolss_PrinterEnumValues *v,
1022 const char *valuename, const char **_str)
1023 {
1024 /* just return if it is not the one we are looking for */
1025 if (strcmp(valuename, v->value_name) != 0) {
1026 return WERR_NOT_FOUND;
1027 }
1028
1029 if (v->type != REG_SZ) {
1030 return WERR_INVALID_DATATYPE;
1031 }
1032
1033 if (!pull_reg_sz(mem_ctx, NULL, v->data, _str)) {
1034 return WERR_NOMEM;
1035 }
1036
1037 return WERR_OK;
1038 }
1039
1040 static WERROR winreg_enumval_to_multi_sz(TALLOC_CTX *mem_ctx,
1041 struct spoolss_PrinterEnumValues *v,
1042 const char *valuename,
1043 const char ***array)
1044 {
1045 /* just return if it is not the one we are looking for */
1046 if (strcmp(valuename, v->value_name) != 0) {
1047 return WERR_NOT_FOUND;
1048 }
1049
1050 if (v->type != REG_MULTI_SZ) {
1051 return WERR_INVALID_DATATYPE;
1052 }
1053
1054 if (!pull_reg_multi_sz(mem_ctx, NULL, v->data, array)) {
1055 return WERR_NOMEM;
1056 }
1057
1058 return WERR_OK;
1059 }
1060
1061 static WERROR winreg_enumval_to_blob(TALLOC_CTX *mem_ctx,
1062 struct spoolss_PrinterEnumValues *v,
1063 const char *valuename,
1064 DATA_BLOB *blob)
1065 {
1066 /* just return if it is not the one we are looking for */
1067 if (strcmp(valuename, v->value_name) != 0) {
1068 return WERR_NOT_FOUND;
1069 }
1070
1071 if (v->type != REG_BINARY) {
1072 return WERR_INVALID_DATATYPE;
1073 }
1074
1075 blob->data = v->data->data;
1076 blob->length = v->data_length;
1077
1078 return WERR_OK;
1079 }
1080
1081 static WERROR winreg_printer_write_date(TALLOC_CTX *mem_ctx,
1082 struct rpc_pipe_client *pipe_handle,
1083 struct policy_handle *key_handle,
1084 const char *value,
1085 NTTIME data)
1086 {
1087 struct winreg_String wvalue;
1088 DATA_BLOB blob;
1089 WERROR result = WERR_OK;
1090 NTSTATUS status;
1091 const char *str;
1092 struct tm *tm;
1093 time_t t;
1094
1095 t = nt_time_to_unix(data);
1096 tm = localtime(&t);
1097 str = talloc_asprintf(mem_ctx, "%02d/%02d/%04d",
1098 tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
1099 if (!str) {
1100 return WERR_NOMEM;
1101 }
1102
1103 wvalue.name = value;
1104 if (!push_reg_sz(mem_ctx, NULL, &blob, str)) {
1105 return WERR_NOMEM;
1106 }
1107 status = rpccli_winreg_SetValue(pipe_handle,
1108 mem_ctx,
1109 key_handle,
1110 wvalue,
1111 REG_SZ,
1112 blob.data,
1113 blob.length,
1114 &result);
1115 if (!NT_STATUS_IS_OK(status)) {
1116 DEBUG(0, ("winreg_printer_write_date: Could not set value %s: %s\n",
1117 wvalue.name, win_errstr(result)));
1118 if (!W_ERROR_IS_OK(result)) {
1119 result = ntstatus_to_werror(status);
1120 }
1121 }
1122
1123 return result;
1124 }
1125
1126 static WERROR winreg_printer_date_to_NTTIME(const char *str, NTTIME *data)
1127 {
1128 struct tm tm;
1129 time_t t;
1130
1131 ZERO_STRUCT(tm);
1132
1133 if (sscanf(str, "%d/%d/%d",
1134 &tm.tm_mon, &tm.tm_mday, &tm.tm_year) != 3) {
1135 return WERR_INVALID_PARAMETER;
1136 }
1137 tm.tm_mon -= 1;
1138 tm.tm_year -= 1900;
1139 tm.tm_isdst = -1;
1140
1141 t = mktime(&tm);
1142 unix_to_nt_time(data, t);
1143
1144 return WERR_OK;
1145 }
1146
1147 static WERROR winreg_printer_write_ver(TALLOC_CTX *mem_ctx,
1148 struct rpc_pipe_client *pipe_handle,
1149 struct policy_handle *key_handle,
1150 const char *value,
1151 uint64_t data)
1152 {
1153 struct winreg_String wvalue;
1154 DATA_BLOB blob;
1155 WERROR result = WERR_OK;
1156 NTSTATUS status;
1157 char *str;
1158
1159 /* FIXME: check format is right,
1160 * this needs to be something like: 6.1.7600.16385 */
1161 str = talloc_asprintf(mem_ctx, "%u.%u.%u.%u",
1162 (unsigned)((data >> 48) & 0xFFFF),
1163 (unsigned)((data >> 32) & 0xFFFF),
1164 (unsigned)((data >> 16) & 0xFFFF),
1165 (unsigned)(data & 0xFFFF));
1166 if (!str) {
1167 return WERR_NOMEM;
1168 }
1169
1170 wvalue.name = value;
1171 if (!push_reg_sz(mem_ctx, NULL, &blob, str)) {
1172 return WERR_NOMEM;
1173 }
1174 status = rpccli_winreg_SetValue(pipe_handle,
1175 mem_ctx,
1176 key_handle,
1177 wvalue,
1178 REG_SZ,
1179 blob.data,
1180 blob.length,
1181 &result);
1182 if (!NT_STATUS_IS_OK(status)) {
1183 DEBUG(0, ("winreg_printer_write_date: Could not set value %s: %s\n",
1184 wvalue.name, win_errstr(result)));
1185 if (!W_ERROR_IS_OK(result)) {
1186 result = ntstatus_to_werror(status);
1187 }
1188 }
1189
1190 return result;
1191 }
1192
1193 static WERROR winreg_printer_ver_to_dword(const char *str, uint64_t *data)
1194 {
1195 unsigned int v1, v2, v3, v4;
1196
1197 if (sscanf(str, "%u.%u.%u.%u", &v1, &v2, &v3, &v4) != 4) {
1198 return WERR_INVALID_PARAMETER;
1199 }
1200
1201 *data = ((uint64_t)(v1 & 0xFFFF) << 48) +
1202 ((uint64_t)(v2 & 0xFFFF) << 32) +
1203 ((uint64_t)(v3 & 0xFFFF) << 16) +
1204 (uint64_t)(v2 & 0xFFFF);
1205
1206 return WERR_OK;
1207 }
1208
1209 /********************************************************************
1210 Public winreg function for spoolss
1211 ********************************************************************/
1212
1213 /* Set printer data over the winreg pipe. */
1214 WERROR winreg_set_printer_dataex(TALLOC_CTX *mem_ctx,
1215 struct auth_serversupplied_info *server_info,
1216 const char *printer,
1217 const char *key,
1218 const char *value,
1219 enum winreg_Type type,
1220 uint8_t *data,
1221 uint32_t data_size)
1222 {
1223 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1224 struct rpc_pipe_client *winreg_pipe = NULL;
1225 struct policy_handle hive_hnd, key_hnd;
1226 struct winreg_String wvalue;
1227 char *path;
1228 WERROR result = WERR_OK;
1229 NTSTATUS status;
1230 TALLOC_CTX *tmp_ctx;
1231
1232 tmp_ctx = talloc_new(mem_ctx);
1233 if (tmp_ctx == NULL) {
1234 return WERR_NOMEM;
1235 }
1236
1237 path = winreg_printer_data_keyname(tmp_ctx, printer);
1238 if (path == NULL) {
1239 TALLOC_FREE(tmp_ctx);
1240 return WERR_NOMEM;
1241 }
1242
1243 ZERO_STRUCT(hive_hnd);
1244 ZERO_STRUCT(key_hnd);
1245
1246 DEBUG(8, ("winreg_set_printer_dataex: Open printer key %s, value %s, access_mask: 0x%05x for [%s]\n",
1247 key, value, access_mask, printer));
1248 result = winreg_printer_openkey(tmp_ctx,
1249 server_info,
1250 &winreg_pipe,
1251 path,
1252 key,
1253 true,
1254 access_mask,
1255 &hive_hnd,
1256 &key_hnd);
1257 if (!W_ERROR_IS_OK(result)) {
1258 DEBUG(0, ("winreg_set_printer_dataex: Could not open key %s: %s\n",
1259 key, win_errstr(result)));
1260 goto done;
1261 }
1262
1263 wvalue.name = value;
1264 status = rpccli_winreg_SetValue(winreg_pipe,
1265 tmp_ctx,
1266 &key_hnd,
1267 wvalue,
1268 type,
1269 data,
1270 data_size,
1271 &result);
1272 if (!NT_STATUS_IS_OK(status)) {
1273 DEBUG(0, ("winreg_set_printer_dataex: Could not set value %s: %s\n",
1274 value, nt_errstr(status)));
1275 if (!W_ERROR_IS_OK(result)) {
1276 goto done;
1277 }
1278 result = ntstatus_to_werror(status);
1279 goto done;
1280 }
1281
1282 result = WERR_OK;
1283 done:
1284 if (winreg_pipe != NULL) {
1285 if (is_valid_policy_hnd(&key_hnd)) {
1286 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1287 }
1288 if (is_valid_policy_hnd(&hive_hnd)) {
1289 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1290 }
1291 }
1292
1293 TALLOC_FREE(tmp_ctx);
1294 return result;
1295 }
1296
1297 /* Get printer data over a winreg pipe. */
1298 WERROR winreg_get_printer_dataex(TALLOC_CTX *mem_ctx,
1299 struct auth_serversupplied_info *server_info,
1300 const char *printer,
1301 const char *key,
1302 const char *value,
1303 enum winreg_Type *type,
1304 uint8_t **data,
1305 uint32_t *data_size)
1306 {
1307 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1308 struct rpc_pipe_client *winreg_pipe = NULL;
1309 struct policy_handle hive_hnd, key_hnd;
1310 struct winreg_String wvalue;
1311 enum winreg_Type type_in;
1312 char *path;
1313 uint8_t *data_in;
1314 uint32_t data_in_size = 0;
1315 uint32_t value_len = 0;
1316 WERROR result = WERR_OK;
1317 NTSTATUS status;
1318 TALLOC_CTX *tmp_ctx;
1319
1320 tmp_ctx = talloc_new(mem_ctx);
1321 if (tmp_ctx == NULL) {
1322 return WERR_NOMEM;
1323 }
1324
1325 path = winreg_printer_data_keyname(tmp_ctx, printer);
1326 if (path == NULL) {
1327 TALLOC_FREE(tmp_ctx);
1328 return WERR_NOMEM;
1329 }
1330
1331 ZERO_STRUCT(hive_hnd);
1332 ZERO_STRUCT(key_hnd);
1333
1334 result = winreg_printer_openkey(tmp_ctx,
1335 server_info,
1336 &winreg_pipe,
1337 path,
1338 key,
1339 false,
1340 access_mask,
1341 &hive_hnd,
1342 &key_hnd);
1343 if (!W_ERROR_IS_OK(result)) {
1344 DEBUG(0, ("winreg_get_printer_dataex: Could not open key %s: %s\n",
1345 key, win_errstr(result)));
1346 goto done;
1347 }
1348
1349 wvalue.name = value;
1350
1351 /*
1352 * call QueryValue once with data == NULL to get the
1353 * needed memory size to be allocated, then allocate
1354 * data buffer and call again.
1355 */
1356 status = rpccli_winreg_QueryValue(winreg_pipe,
1357 tmp_ctx,
1358 &key_hnd,
1359 &wvalue,
1360 &type_in,
1361 NULL,
1362 &data_in_size,
1363 &value_len,
1364 &result);
1365 if (!NT_STATUS_IS_OK(status)) {
1366 DEBUG(0, ("winreg_get_printer_dataex: Could not query value %s: %s\n",
1367 value, nt_errstr(status)));
1368 if (!W_ERROR_IS_OK(result)) {
1369 goto done;
1370 }
1371 result = ntstatus_to_werror(status);
1372 goto done;
1373 }
1374
1375 data_in = (uint8_t *) TALLOC(tmp_ctx, data_in_size);
1376 if (data_in == NULL) {
1377 result = WERR_NOMEM;
1378 goto done;
1379 }
1380 value_len = 0;
1381
1382 status = rpccli_winreg_QueryValue(winreg_pipe,
1383 tmp_ctx,
1384 &key_hnd,
1385 &wvalue,
1386 &type_in,
1387 data_in,
1388 &data_in_size,
1389 &value_len,
1390 &result);
1391 if (!NT_STATUS_IS_OK(status)) {
1392 DEBUG(0, ("winreg_get_printer_dataex: Could not query value %s: %s\n",
1393 value, nt_errstr(status)));
1394 if (!W_ERROR_IS_OK(result)) {
1395 result = ntstatus_to_werror(status);
1396 }
1397 goto done;
1398 }
1399
1400 *type = type_in;
1401 *data_size = data_in_size;
1402 if (data_in_size) {
1403 *data = talloc_move(mem_ctx, &data_in);
1404 }
1405
1406 result = WERR_OK;
1407 done:
1408 if (winreg_pipe != NULL) {
1409 if (is_valid_policy_hnd(&key_hnd)) {
1410 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1411 }
1412 if (is_valid_policy_hnd(&hive_hnd)) {
1413 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1414 }
1415 }
1416
1417 TALLOC_FREE(tmp_ctx);
1418 return result;
1419 }
1420
1421 /* Enumerate on the values of a given key and provide the data. */
1422 WERROR winreg_enum_printer_dataex(TALLOC_CTX *mem_ctx,
1423 struct auth_serversupplied_info *server_info,
1424 const char *printer,
1425 const char *key,
1426 uint32_t *pnum_values,
1427 struct spoolss_PrinterEnumValues **penum_values)
1428 {
1429 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1430 struct rpc_pipe_client *winreg_pipe = NULL;
1431 struct policy_handle hive_hnd, key_hnd;
1432
1433 struct spoolss_PrinterEnumValues *enum_values = NULL;
1434 uint32_t num_values = 0;
1435 char *path;
1436 WERROR result = WERR_OK;
1437
1438 TALLOC_CTX *tmp_ctx;
1439
1440 tmp_ctx = talloc_new(mem_ctx);
1441 if (tmp_ctx == NULL) {
1442 return WERR_NOMEM;
1443 }
1444
1445 path = winreg_printer_data_keyname(tmp_ctx, printer);
1446 if (path == NULL) {
1447 TALLOC_FREE(tmp_ctx);
1448 return WERR_NOMEM;
1449 }
1450
1451 result = winreg_printer_openkey(tmp_ctx,
1452 server_info,
1453 &winreg_pipe,
1454 path,
1455 key,
1456 false,
1457 access_mask,
1458 &hive_hnd,
1459 &key_hnd);
1460 if (!W_ERROR_IS_OK(result)) {
1461 DEBUG(0, ("winreg_enum_printer_dataex: Could not open key %s: %s\n",
1462 key, win_errstr(result)));
1463 goto done;
1464 }
1465
1466 result = winreg_printer_enumvalues(tmp_ctx,
1467 winreg_pipe,
1468 &key_hnd,
1469 &num_values,
1470 &enum_values);
1471 if (!W_ERROR_IS_OK(result)) {
1472 DEBUG(0, ("winreg_enum_printer_dataex: Could not enumerate values in %s: %s\n",
1473 key, win_errstr(result)));
1474 goto done;
1475 }
1476
1477 *pnum_values = num_values;
1478 if (penum_values) {
1479 *penum_values = talloc_move(mem_ctx, &enum_values);
1480 }
1481
1482 result = WERR_OK;
1483 done:
1484 if (winreg_pipe != NULL) {
1485 if (is_valid_policy_hnd(&key_hnd)) {
1486 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1487 }
1488 if (is_valid_policy_hnd(&hive_hnd)) {
1489 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1490 }
1491 }
1492
1493 TALLOC_FREE(tmp_ctx);
1494 return result;
1495 }
1496
1497 /* Delete printer data over a winreg pipe. */
1498 WERROR winreg_delete_printer_dataex(TALLOC_CTX *mem_ctx,
1499 struct auth_serversupplied_info *server_info,
1500 const char *printer,
1501 const char *key,
1502 const char *value)
1503 {
1504 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1505 struct rpc_pipe_client *winreg_pipe = NULL;
1506 struct policy_handle hive_hnd, key_hnd;
1507 struct winreg_String wvalue;
1508 char *path;
1509 WERROR result = WERR_OK;
1510 NTSTATUS status;
1511
1512 TALLOC_CTX *tmp_ctx;
1513
1514 tmp_ctx = talloc_new(mem_ctx);
1515 if (tmp_ctx == NULL) {
1516 return WERR_NOMEM;
1517 }
1518
1519 path = winreg_printer_data_keyname(tmp_ctx, printer);
1520 if (path == NULL) {
1521 TALLOC_FREE(tmp_ctx);
1522 return WERR_NOMEM;
1523 }
1524
1525 ZERO_STRUCT(hive_hnd);
1526 ZERO_STRUCT(key_hnd);
1527
1528 result = winreg_printer_openkey(tmp_ctx,
1529 server_info,
1530 &winreg_pipe,
1531 path,
1532 key,
1533 false,
1534 access_mask,
1535 &hive_hnd,
1536 &key_hnd);
1537 if (!W_ERROR_IS_OK(result)) {
1538 DEBUG(0, ("winreg_delete_printer_dataex: Could not open key %s: %s\n",
1539 key, win_errstr(result)));
1540 goto done;
1541 }
1542
1543 wvalue.name = value;
1544 status = rpccli_winreg_DeleteValue(winreg_pipe,
1545 tmp_ctx,
1546 &key_hnd,
1547 wvalue,
1548 &result);
1549 if (!NT_STATUS_IS_OK(status)) {
1550 DEBUG(0, ("winreg_delete_printer_dataex: Could not delete value %s: %s\n",
1551 value, nt_errstr(status)));
1552 if (!W_ERROR_IS_OK(result)) {
1553 goto done;
1554 }
1555 result = ntstatus_to_werror(status);
1556 goto done;
1557 }
1558
1559 result = WERR_OK;
1560 done:
1561 if (winreg_pipe != NULL) {
1562 if (is_valid_policy_hnd(&key_hnd)) {
1563 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1564 }
1565 if (is_valid_policy_hnd(&hive_hnd)) {
1566 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1567 }
1568 }
1569
1570 TALLOC_FREE(tmp_ctx);
1571 return result;
1572 }
1573
1574 /* Enumerate on the subkeys of a given key and provide the data. */
1575 WERROR winreg_enum_printer_key(TALLOC_CTX *mem_ctx,
1576 struct auth_serversupplied_info *server_info,
1577 const char *printer,
1578 const char *key,
1579 uint32_t *pnum_subkeys,
1580 const char ***psubkeys)
1581 {
1582 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1583 struct rpc_pipe_client *winreg_pipe = NULL;
1584 struct policy_handle hive_hnd, key_hnd;
1585 char *path;
1586 const char **subkeys = NULL;
1587 uint32_t num_subkeys = -1;
1588
1589 WERROR result = WERR_OK;
1590
1591 TALLOC_CTX *tmp_ctx;
1592
1593 tmp_ctx = talloc_new(mem_ctx);
1594 if (tmp_ctx == NULL) {
1595 return WERR_NOMEM;
1596 }
1597
1598 path = winreg_printer_data_keyname(tmp_ctx, printer);
1599 if (path == NULL) {
1600 TALLOC_FREE(tmp_ctx);
1601 return WERR_NOMEM;
1602 }
1603
1604 ZERO_STRUCT(hive_hnd);
1605 ZERO_STRUCT(key_hnd);
1606
1607 result = winreg_printer_openkey(tmp_ctx,
1608 server_info,
1609 &winreg_pipe,
1610 path,
1611 key,
1612 false,
1613 access_mask,
1614 &hive_hnd,
1615 &key_hnd);
1616 if (!W_ERROR_IS_OK(result)) {
1617 DEBUG(0, ("winreg_enum_printer_key: Could not open key %s: %s\n",
1618 key, win_errstr(result)));
1619 goto done;
1620 }
1621
1622 result = winreg_printer_enumkeys(tmp_ctx,
1623 winreg_pipe,
1624 &key_hnd,
1625 &num_subkeys,
1626 &subkeys);
1627 if (!W_ERROR_IS_OK(result)) {
1628 DEBUG(0, ("winreg_enum_printer_key: Could not enumerate subkeys in %s: %s\n",
1629 key, win_errstr(result)));
1630 goto done;
1631 }
1632
1633 *pnum_subkeys = num_subkeys;
1634 if (psubkeys) {
1635 *psubkeys = talloc_move(mem_ctx, &subkeys);
1636 }
1637
1638 result = WERR_OK;
1639 done:
1640 if (winreg_pipe != NULL) {
1641 if (is_valid_policy_hnd(&key_hnd)) {
1642 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1643 }
1644 if (is_valid_policy_hnd(&hive_hnd)) {
1645 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1646 }
1647 }
1648
1649 TALLOC_FREE(tmp_ctx);
1650 return result;
1651 }
1652
1653 /* Delete a key with subkeys of a given printer. */
1654 WERROR winreg_delete_printer_key(TALLOC_CTX *mem_ctx,
1655 struct auth_serversupplied_info *server_info,
1656 const char *printer,
1657 const char *key)
1658 {
1659 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1660 struct rpc_pipe_client *winreg_pipe = NULL;
1661 struct policy_handle hive_hnd, key_hnd;
1662 char *keyname;
1663 char *path;
1664 WERROR result;
1665 TALLOC_CTX *tmp_ctx;
1666
1667 tmp_ctx = talloc_new(mem_ctx);
1668 if (tmp_ctx == NULL) {
1669 return WERR_NOMEM;
1670 }
1671
1672 path = winreg_printer_data_keyname(tmp_ctx, printer);
1673 if (path == NULL) {
1674 TALLOC_FREE(tmp_ctx);
1675 return WERR_NOMEM;
1676 }
1677
1678 result = winreg_printer_openkey(tmp_ctx,
1679 server_info,
1680 &winreg_pipe,
1681 path,
1682 key,
1683 false,
1684 access_mask,
1685 &hive_hnd,
1686 &key_hnd);
1687 if (!W_ERROR_IS_OK(result)) {
1688 /* key doesn't exist */
1689 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
1690 result = WERR_OK;
1691 goto done;
1692 }
1693
1694 DEBUG(0, ("winreg_delete_printer_key: Could not open key %s: %s\n",
1695 key, win_errstr(result)));
1696 goto done;
1697 }
1698
1699 if (is_valid_policy_hnd(&key_hnd)) {
1700 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1701 }
1702
1703 if (key == NULL || key[0] == '\0') {
1704 keyname = path;
1705 } else {
1706 keyname = talloc_asprintf(tmp_ctx,
1707 "%s\\%s",
1708 path,
1709 key);
1710 if (keyname == NULL) {
1711 result = WERR_NOMEM;
1712 goto done;
1713 }
1714 }
1715
1716 result = winreg_printer_delete_subkeys(tmp_ctx,
1717 winreg_pipe,
1718 &hive_hnd,
1719 access_mask,
1720 keyname);
1721 if (!W_ERROR_IS_OK(result)) {
1722 DEBUG(0, ("winreg_delete_printer_key: Could not delete key %s: %s\n",
1723 key, win_errstr(result)));
1724 goto done;
1725 }
1726
1727 done:
1728 if (winreg_pipe != NULL) {
1729 if (is_valid_policy_hnd(&key_hnd)) {
1730 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1731 }
1732 if (is_valid_policy_hnd(&hive_hnd)) {
1733 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1734 }
1735 }
1736
1737 TALLOC_FREE(tmp_ctx);
1738 return result;
1739 }
1740
1741 WERROR winreg_printer_update_changeid(TALLOC_CTX *mem_ctx,
1742 struct auth_serversupplied_info *server_info,
1743 const char *printer)
1744 {
1745 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1746 struct rpc_pipe_client *winreg_pipe = NULL;
1747 struct policy_handle hive_hnd, key_hnd;
1748 char *path;
1749 WERROR result;
1750 TALLOC_CTX *tmp_ctx;
1751
1752 tmp_ctx = talloc_new(mem_ctx);
1753 if (tmp_ctx == NULL) {
1754 return WERR_NOMEM;
1755 }
1756
1757 path = winreg_printer_data_keyname(tmp_ctx, printer);
1758 if (path == NULL) {
1759 TALLOC_FREE(tmp_ctx);
1760 return WERR_NOMEM;
1761 }
1762
1763 ZERO_STRUCT(hive_hnd);
1764 ZERO_STRUCT(key_hnd);
1765
1766 result = winreg_printer_openkey(tmp_ctx,
1767 server_info,
1768 &winreg_pipe,
1769 path,
1770 "",
1771 false,
1772 access_mask,
1773 &hive_hnd,
1774 &key_hnd);
1775 if (!W_ERROR_IS_OK(result)) {
1776 DEBUG(0, ("winreg_printer_update_changeid: Could not open key %s: %s\n",
1777 path, win_errstr(result)));
1778 goto done;
1779 }
1780
1781 result = winreg_printer_write_dword(tmp_ctx,
1782 winreg_pipe,
1783 &key_hnd,
1784 "ChangeID",
1785 winreg_printer_rev_changeid());
1786 if (!W_ERROR_IS_OK(result)) {
1787 goto done;
1788 }
1789
1790 result = WERR_OK;
1791 done:
1792 if (winreg_pipe != NULL) {
1793 if (is_valid_policy_hnd(&key_hnd)) {
1794 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1795 }
1796 if (is_valid_policy_hnd(&hive_hnd)) {
1797 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1798 }
1799 }
1800
1801 TALLOC_FREE(tmp_ctx);
1802 return result;
1803 }
1804
1805 WERROR winreg_printer_get_changeid(TALLOC_CTX *mem_ctx,
1806 struct auth_serversupplied_info *server_info,
1807 const char *printer,
1808 uint32_t *pchangeid)
1809 {
1810 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1811 struct rpc_pipe_client *winreg_pipe = NULL;
1812 struct policy_handle hive_hnd, key_hnd;
1813 uint32_t changeid = 0;
1814 char *path;
1815 WERROR result;
1816 TALLOC_CTX *tmp_ctx;
1817
1818 tmp_ctx = talloc_new(mem_ctx);
1819 if (tmp_ctx == NULL) {
1820 return WERR_NOMEM;
1821 }
1822
1823 path = winreg_printer_data_keyname(tmp_ctx, printer);
1824 if (path == NULL) {
1825 TALLOC_FREE(tmp_ctx);
1826 return WERR_NOMEM;
1827 }
1828
1829 ZERO_STRUCT(hive_hnd);
1830 ZERO_STRUCT(key_hnd);
1831
1832 result = winreg_printer_openkey(tmp_ctx,
1833 server_info,
1834 &winreg_pipe,
1835 path,
1836 "",
1837 false,
1838 access_mask,
1839 &hive_hnd,
1840 &key_hnd);
1841 if (!W_ERROR_IS_OK(result)) {
1842 DEBUG(0, ("winreg_printer_get_changeid: Could not open key %s: %s\n",
1843 path, win_errstr(result)));
1844 goto done;
1845 }
1846
1847 DEBUG(0, ("winreg_printer_get_changeid: get changeid from %s\n", path));
1848 result = winreg_printer_query_dword(tmp_ctx,
1849 winreg_pipe,
1850 &key_hnd,
1851 "ChangeID",
1852 &changeid);
1853 if (!W_ERROR_IS_OK(result)) {
1854 goto done;
1855 }
1856
1857 if (pchangeid) {
1858 *pchangeid = changeid;
1859 }
1860
1861 result = WERR_OK;
1862 done:
1863 if (winreg_pipe != NULL) {
1864 if (is_valid_policy_hnd(&key_hnd)) {
1865 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1866 }
1867 if (is_valid_policy_hnd(&hive_hnd)) {
1868 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1869 }
1870 }
1871
1872 TALLOC_FREE(tmp_ctx);
1873 return result;
1874 }
1875
1876 /*
1877 * The special behaviour of the spoolss forms is documented at the website:
1878 *
1879 * Managing Win32 Printserver Forms
1880 * http://unixwiz.net/techtips/winspooler-forms.html
1881 */
1882
1883 WERROR winreg_printer_addform1(TALLOC_CTX *mem_ctx,
1884 struct auth_serversupplied_info *server_info,
1885 struct spoolss_AddFormInfo1 *form)
1886 {
1887 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1888 struct rpc_pipe_client *winreg_pipe = NULL;
1889 struct policy_handle hive_hnd, key_hnd;
1890 struct winreg_String wvalue;
1891 DATA_BLOB blob;
1892 uint32_t num_info = 0;
1893 union spoolss_FormInfo *info = NULL;
1894 uint32_t i;
1895 WERROR result;
1896 NTSTATUS status;
1897 TALLOC_CTX *tmp_ctx;
1898
1899 tmp_ctx = talloc_new(mem_ctx);
1900 if (tmp_ctx == NULL) {
1901 return WERR_NOMEM;
1902 }
1903
1904 ZERO_STRUCT(hive_hnd);
1905 ZERO_STRUCT(key_hnd);
1906
1907 result = winreg_printer_openkey(tmp_ctx,
1908 server_info,
1909 &winreg_pipe,
1910 TOP_LEVEL_CONTROL_FORMS_KEY,
1911 "",
1912 true,
1913 access_mask,
1914 &hive_hnd,
1915 &key_hnd);
1916 if (!W_ERROR_IS_OK(result)) {
1917 DEBUG(0, ("winreg_printer_addform1: Could not open key %s: %s\n",
1918 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
1919 goto done;
1920 }
1921
1922 result = winreg_printer_enumforms1(tmp_ctx, server_info, &num_info, &info);
1923 if (!W_ERROR_IS_OK(result)) {
1924 DEBUG(0, ("winreg_printer_addform: Could not enum keys %s: %s\n",
1925 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
1926 goto done;
1927 }
1928
1929 /* If form name already exists or is builtin return ALREADY_EXISTS */
1930 for (i = 0; i < num_info; i++) {
1931 if (strequal(info[i].info1.form_name, form->form_name)) {
1932 result = WERR_FILE_EXISTS;
1933 goto done;
1934 }
1935 }
1936
1937 wvalue.name = form->form_name;
1938
1939 blob = data_blob_talloc(tmp_ctx, NULL, 32);
1940 SIVAL(blob.data, 0, form->size.width);
1941 SIVAL(blob.data, 4, form->size.height);
1942 SIVAL(blob.data, 8, form->area.left);
1943 SIVAL(blob.data, 12, form->area.top);
1944 SIVAL(blob.data, 16, form->area.right);
1945 SIVAL(blob.data, 20, form->area.bottom);
1946 SIVAL(blob.data, 24, num_info + 1); /* FIXME */
1947 SIVAL(blob.data, 28, form->flags);
1948
1949 status = rpccli_winreg_SetValue(winreg_pipe,
1950 tmp_ctx,
1951 &key_hnd,
1952 wvalue,
1953 REG_BINARY,
1954 blob.data,
1955 blob.length,
1956 &result);
1957 if (!NT_STATUS_IS_OK(status)) {
1958 DEBUG(0, ("winreg_printer_addform1: Could not set value %s: %s\n",
1959 wvalue.name, nt_errstr(status)));
1960 if (!W_ERROR_IS_OK(result)) {
1961 goto done;
1962 }
1963 result = ntstatus_to_werror(status);
1964 goto done;
1965 }
1966
1967 result = WERR_OK;
1968 done:
1969 if (winreg_pipe != NULL) {
1970 if (is_valid_policy_hnd(&key_hnd)) {
1971 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1972 }
1973 if (is_valid_policy_hnd(&hive_hnd)) {
1974 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1975 }
1976 }
1977
1978 TALLOC_FREE(info);
1979 TALLOC_FREE(tmp_ctx);
1980 return result;
1981 }
1982
1983 WERROR winreg_printer_enumforms1(TALLOC_CTX *mem_ctx,
1984 struct auth_serversupplied_info *server_info,
1985 uint32_t *pnum_info,
1986 union spoolss_FormInfo **pinfo)
1987 {
1988 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1989 struct rpc_pipe_client *winreg_pipe = NULL;
1990 struct policy_handle hive_hnd, key_hnd;
1991 union spoolss_FormInfo *info;
1992 struct spoolss_PrinterEnumValues *enum_values = NULL;
1993 uint32_t num_values = 0;
1994 uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
1995 uint32_t i;
1996 WERROR result;
1997 TALLOC_CTX *tmp_ctx;
1998
1999 tmp_ctx = talloc_new(mem_ctx);
2000 if (tmp_ctx == NULL) {
2001 return WERR_NOMEM;
2002 }
2003
2004 ZERO_STRUCT(hive_hnd);
2005 ZERO_STRUCT(key_hnd);
2006
2007 result = winreg_printer_openkey(tmp_ctx,
2008 server_info,
2009 &winreg_pipe,
2010 TOP_LEVEL_CONTROL_FORMS_KEY,
2011 "",
2012 true,
2013 access_mask,
2014 &hive_hnd,
2015 &key_hnd);
2016 if (!W_ERROR_IS_OK(result)) {
2017 /* key doesn't exist */
2018 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2019 result = WERR_OK;
2020 goto done;
2021 }
2022
2023 DEBUG(0, ("winreg_printer_enumforms1: Could not open key %s: %s\n",
2024 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2025 goto done;
2026 }
2027
2028 result = winreg_printer_enumvalues(tmp_ctx,
2029 winreg_pipe,
2030 &key_hnd,
2031 &num_values,
2032 &enum_values);
2033 if (!W_ERROR_IS_OK(result)) {
2034 DEBUG(0, ("winreg_printer_enumforms1: Could not enumerate values in %s: %s\n",
2035 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2036 goto done;
2037 }
2038
2039 info = TALLOC_ARRAY(tmp_ctx, union spoolss_FormInfo, num_builtin + num_values);
2040 if (info == NULL) {
2041 result = WERR_NOMEM;
2042 goto done;
2043 }
2044
2045 /* Enumerate BUILTIN forms */
2046 for (i = 0; i < num_builtin; i++) {
2047 info[i].info1 = builtin_forms1[i];
2048 }
2049
2050 /* Enumerate registry forms */
2051 for (i = 0; i < num_values; i++) {
2052 union spoolss_FormInfo val;
2053
2054 if (enum_values[i].type != REG_BINARY ||
2055 enum_values[i].data_length != 32) {
2056 continue;
2057 }
2058
2059 val.info1.form_name = talloc_strdup(info, enum_values[i].value_name);
2060 if (val.info1.form_name == NULL) {
2061 result = WERR_NOMEM;
2062 goto done;
2063 }
2064
2065 val.info1.size.width = IVAL(enum_values[i].data->data, 0);
2066 val.info1.size.height = IVAL(enum_values[i].data->data, 4);
2067 val.info1.area.left = IVAL(enum_values[i].data->data, 8);
2068 val.info1.area.top = IVAL(enum_values[i].data->data, 12);
2069 val.info1.area.right = IVAL(enum_values[i].data->data, 16);
2070 val.info1.area.bottom = IVAL(enum_values[i].data->data, 20);
2071 /* skip form index IVAL(enum_values[i].data->data, 24)));*/
2072 val.info1.flags = IVAL(enum_values[i].data->data, 28);
2073
2074 info[i + num_builtin] = val;
2075 }
2076
2077 *pnum_info = num_builtin + num_values;
2078 if (pinfo) {
2079 *pinfo = talloc_move(mem_ctx, &info);
2080 }
2081
2082 done:
2083 if (winreg_pipe != NULL) {
2084 if (is_valid_policy_hnd(&key_hnd)) {
2085 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2086 }
2087 if (is_valid_policy_hnd(&hive_hnd)) {
2088 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2089 }
2090 }
2091
2092 TALLOC_FREE(enum_values);
2093 TALLOC_FREE(tmp_ctx);
2094 return result;
2095 }
2096
2097 WERROR winreg_printer_deleteform1(TALLOC_CTX *mem_ctx,
2098 struct auth_serversupplied_info *server_info,
2099 const char *form_name)
2100 {
2101 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2102 struct rpc_pipe_client *winreg_pipe = NULL;
2103 struct policy_handle hive_hnd, key_hnd;
2104 struct winreg_String wvalue;
2105 uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
2106 uint32_t i;
2107 WERROR result = WERR_OK;
2108 NTSTATUS status;
2109 TALLOC_CTX *tmp_ctx;
2110
2111 for (i = 0; i < num_builtin; i++) {
2112 if (strequal(builtin_forms1[i].form_name, form_name)) {
2113 return WERR_INVALID_PARAMETER;
2114 }
2115 }
2116
2117 tmp_ctx = talloc_new(mem_ctx);
2118 if (tmp_ctx == NULL) {
2119 return WERR_NOMEM;
2120 }
2121
2122 ZERO_STRUCT(hive_hnd);
2123 ZERO_STRUCT(key_hnd);
2124
2125 result = winreg_printer_openkey(tmp_ctx,
2126 server_info,
2127 &winreg_pipe,
2128 TOP_LEVEL_CONTROL_FORMS_KEY,
2129 "",
2130 false,
2131 access_mask,
2132 &hive_hnd,
2133 &key_hnd);
2134 if (!W_ERROR_IS_OK(result)) {
2135 DEBUG(0, ("winreg_printer_deleteform1: Could not open key %s: %s\n",
2136 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2137 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2138 result = WERR_INVALID_FORM_NAME;
2139 }
2140 goto done;
2141 }
2142
2143 wvalue.name = form_name;
2144 status = rpccli_winreg_DeleteValue(winreg_pipe,
2145 tmp_ctx,
2146 &key_hnd,
2147 wvalue,
2148 &result);
2149 if (!NT_STATUS_IS_OK(status)) {
2150 /* If the value doesn't exist, return WERR_INVALID_FORM_NAME */
2151 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2152 result = WERR_INVALID_FORM_NAME;
2153 goto done;
2154 }
2155 DEBUG(0, ("winreg_printer_delteform1: Could not delete value %s: %s\n",
2156 wvalue.name, nt_errstr(status)));
2157 if (!W_ERROR_IS_OK(result)) {
2158 goto done;
2159 }
2160 result = ntstatus_to_werror(status);
2161 goto done;
2162 }
2163
2164 result = WERR_OK;
2165 done:
2166 if (winreg_pipe != NULL) {
2167 if (is_valid_policy_hnd(&key_hnd)) {
2168 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2169 }
2170 if (is_valid_policy_hnd(&hive_hnd)) {
2171 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2172 }
2173 }
2174
2175 TALLOC_FREE(tmp_ctx);
2176 return result;
2177 }
2178
2179 WERROR winreg_printer_setform1(TALLOC_CTX *mem_ctx,
2180 struct auth_serversupplied_info *server_info,
2181 const char *form_name,
2182 struct spoolss_AddFormInfo1 *form)
2183 {
2184 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2185 struct rpc_pipe_client *winreg_pipe = NULL;
2186 struct policy_handle hive_hnd, key_hnd;
2187 struct winreg_String wvalue;
2188 DATA_BLOB blob;
2189 uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
2190 uint32_t i;
2191 WERROR result;
2192 NTSTATUS status;
2193 TALLOC_CTX *tmp_ctx = NULL;
2194
2195 for (i = 0; i < num_builtin; i++) {
2196 if (strequal(builtin_forms1[i].form_name, form->form_name)) {
2197 result = WERR_INVALID_PARAM;
2198 goto done;
2199 }
2200 }
2201
2202 tmp_ctx = talloc_new(mem_ctx);
2203 if (tmp_ctx == NULL) {
2204 return WERR_NOMEM;
2205 }
2206
2207 ZERO_STRUCT(hive_hnd);
2208 ZERO_STRUCT(key_hnd);
2209
2210 result = winreg_printer_openkey(tmp_ctx,
2211 server_info,
2212 &winreg_pipe,
2213 TOP_LEVEL_CONTROL_FORMS_KEY,
2214 "",
2215 true,
2216 access_mask,
2217 &hive_hnd,
2218 &key_hnd);
2219 if (!W_ERROR_IS_OK(result)) {
2220 DEBUG(0, ("winreg_printer_setform1: Could not open key %s: %s\n",
2221 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2222 goto done;
2223 }
2224
2225 /* If form_name != form->form_name then we renamed the form */
2226 if (strequal(form_name, form->form_name)) {
2227 result = winreg_printer_deleteform1(tmp_ctx, server_info, form_name);
2228 if (!W_ERROR_IS_OK(result)) {
2229 DEBUG(0, ("winreg_printer_setform1: Could not open key %s: %s\n",
2230 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2231 goto done;
2232 }
2233 }
2234
2235 wvalue.name = form->form_name;
2236
2237 blob = data_blob_talloc(tmp_ctx, NULL, 32);
2238 SIVAL(blob.data, 0, form->size.width);
2239 SIVAL(blob.data, 4, form->size.height);
2240 SIVAL(blob.data, 8, form->area.left);
2241 SIVAL(blob.data, 12, form->area.top);
2242 SIVAL(blob.data, 16, form->area.right);
2243 SIVAL(blob.data, 20, form->area.bottom);
2244 SIVAL(blob.data, 24, 42);
2245 SIVAL(blob.data, 28, form->flags);
2246
2247 status = rpccli_winreg_SetValue(winreg_pipe,
2248 tmp_ctx,
2249 &key_hnd,
2250 wvalue,
2251 REG_BINARY,
2252 blob.data,
2253 blob.length,
2254 &result);
2255 if (!NT_STATUS_IS_OK(status)) {
2256 DEBUG(0, ("winreg_printer_setform1: Could not set value %s: %s\n",
2257 wvalue.name, nt_errstr(status)));
2258 if (!W_ERROR_IS_OK(result)) {
2259 goto done;
2260 }
2261 result = ntstatus_to_werror(status);
2262 goto done;
2263 }
2264
2265 result = WERR_OK;
2266 done:
2267 if (winreg_pipe != NULL) {
2268 if (is_valid_policy_hnd(&key_hnd)) {
2269 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2270 }
2271 if (is_valid_policy_hnd(&hive_hnd)) {
2272 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2273 }
2274 }
2275
2276 TALLOC_FREE(tmp_ctx);
2277 return result;
2278 }
2279
2280 WERROR winreg_printer_getform1(TALLOC_CTX *mem_ctx,
2281 struct auth_serversupplied_info *server_info,
2282 const char *form_name,
2283 struct spoolss_FormInfo1 *r)
2284 {
2285 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2286 struct rpc_pipe_client *winreg_pipe = NULL;
2287 struct policy_handle hive_hnd, key_hnd;
2288 struct winreg_String wvalue;
2289 enum winreg_Type type_in;
2290 uint8_t *data_in;
2291 uint32_t data_in_size = 0;
2292 uint32_t value_len = 0;
2293 uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
2294 uint32_t i;
2295 WERROR result;
2296 NTSTATUS status;
2297 TALLOC_CTX *tmp_ctx;
2298
2299 /* check builtin forms first */
2300 for (i = 0; i < num_builtin; i++) {
2301 if (strequal(builtin_forms1[i].form_name, form_name)) {
2302 *r = builtin_forms1[i];
2303 return WERR_OK;
2304 }
2305 }
2306
2307 tmp_ctx = talloc_new(mem_ctx);
2308 if (tmp_ctx == NULL) {
2309 return WERR_NOMEM;
2310 }
2311
2312 ZERO_STRUCT(hive_hnd);
2313 ZERO_STRUCT(key_hnd);
2314
2315 result = winreg_printer_openkey(tmp_ctx,
2316 server_info,
2317 &winreg_pipe,
2318 TOP_LEVEL_CONTROL_FORMS_KEY,
2319 "",
2320 true,
2321 access_mask,
2322 &hive_hnd,
2323 &key_hnd);
2324 if (!W_ERROR_IS_OK(result)) {
2325 DEBUG(0, ("winreg_printer_getform1: Could not open key %s: %s\n",
2326 TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2327 goto done;
2328 }
2329
2330 wvalue.name = form_name;
2331
2332 /*
2333 * call QueryValue once with data == NULL to get the
2334 * needed memory size to be allocated, then allocate
2335 * data buffer and call again.
2336 */
2337 status = rpccli_winreg_QueryValue(winreg_pipe,
2338 tmp_ctx,
2339 &key_hnd,
2340 &wvalue,
2341 &type_in,
2342 NULL,
2343 &data_in_size,
2344 &value_len,
2345 &result);
2346 if (!NT_STATUS_IS_OK(status)) {
2347 DEBUG(0, ("winreg_printer_getform1: Could not query value %s: %s\n",
2348 wvalue.name, nt_errstr(status)));
2349 if (!W_ERROR_IS_OK(result)) {
2350 goto done;
2351 }
2352 result = ntstatus_to_werror(status);
2353 goto done;
2354 }
2355
2356 data_in = (uint8_t *) TALLOC(tmp_ctx, data_in_size);
2357 if (data_in == NULL) {
2358 result = WERR_NOMEM;
2359 goto done;
2360 }
2361 value_len = 0;
2362
2363 status = rpccli_winreg_QueryValue(winreg_pipe,
2364 tmp_ctx,
2365 &key_hnd,
2366 &wvalue,
2367 &type_in,
2368 data_in,
2369 &data_in_size,
2370 &value_len,
2371 &result);
2372 if (!NT_STATUS_IS_OK(status)) {
2373 DEBUG(0, ("winreg_printer_getform1: Could not query value %s: %s\n",
2374 wvalue.name, nt_errstr(status)));
2375 if (!W_ERROR_IS_OK(result)) {
2376 goto done;
2377 }
2378 result = ntstatus_to_werror(status);
2379 goto done;
2380 }
2381
2382 r->form_name = talloc_strdup(mem_ctx, form_name);
2383 if (r->form_name == NULL) {
2384 result = WERR_NOMEM;
2385 goto done;
2386 }
2387
2388 r->size.width = IVAL(data_in, 0);
2389 r->size.height = IVAL(data_in, 4);
2390 r->area.left = IVAL(data_in, 8);
2391 r->area.top = IVAL(data_in, 12);
2392 r->area.right = IVAL(data_in, 16);
2393 r->area.bottom = IVAL(data_in, 20);
2394 /* skip index IVAL(data_in, 24)));*/
2395 r->flags = IVAL(data_in, 28);
2396
2397 result = WERR_OK;
2398 done:
2399 if (winreg_pipe != NULL) {
2400 if (is_valid_policy_hnd(&key_hnd)) {
2401 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2402 }
2403 if (is_valid_policy_hnd(&hive_hnd)) {
2404 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2405 }
2406 }
2407
2408 TALLOC_FREE(tmp_ctx);
2409 return result;
2410 }
2411
2412 WERROR winreg_add_driver(TALLOC_CTX *mem_ctx,
2413 struct auth_serversupplied_info *server_info,
2414 struct spoolss_AddDriverInfoCtr *r,
2415 const char **driver_name,
2416 uint32_t *driver_version)
2417 {
2418 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2419 struct rpc_pipe_client *winreg_pipe = NULL;
2420 struct policy_handle hive_hnd, key_hnd;
2421 struct spoolss_DriverInfo8 info8;
2422 TALLOC_CTX *tmp_ctx;
2423 WERROR result;
2424
2425 ZERO_STRUCT(hive_hnd);
2426 ZERO_STRUCT(key_hnd);
2427 ZERO_STRUCT(info8);
2428
2429 if (!driver_info_ctr_to_info8(r, &info8)) {
2430 result = WERR_INVALID_PARAMETER;
2431 goto done;
2432 }
2433
2434 tmp_ctx = talloc_new(mem_ctx);
2435 if (tmp_ctx == NULL) {
2436 return WERR_NOMEM;
2437 }
2438
2439 result = winreg_printer_opendriver(tmp_ctx,
2440 server_info,
2441 info8.driver_name,
2442 info8.architecture,
2443 info8.version,
2444 access_mask, true,
2445 &winreg_pipe,
2446 &hive_hnd,
2447 &key_hnd);
2448 if (!W_ERROR_IS_OK(result)) {
2449 DEBUG(0, ("winreg_add_driver: "
2450 "Could not open driver key (%s,%s,%d): %s\n",
2451 info8.driver_name, info8.architecture,
2452 info8.version, win_errstr(result)));
2453 goto done;
2454 }
2455
2456 /* TODO: "Attributes" ? */
2457
2458 result = winreg_printer_write_dword(tmp_ctx, winreg_pipe,
2459 &key_hnd, "Version",
2460 info8.version);
2461 if (!W_ERROR_IS_OK(result)) {
2462 goto done;
2463 }
2464
2465 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2466 &key_hnd, "Driver",
2467 info8.driver_path);
2468 if (!W_ERROR_IS_OK(result)) {
2469 goto done;
2470 }
2471
2472 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2473 &key_hnd, "Data File",
2474 info8.data_file);
2475 if (!W_ERROR_IS_OK(result)) {
2476 goto done;
2477 }
2478
2479 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2480 &key_hnd, "Configuration File",
2481 info8.config_file);
2482 if (!W_ERROR_IS_OK(result)) {
2483 goto done;
2484 }
2485
2486 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2487 &key_hnd, "Help File",
2488 info8.help_file);
2489 if (!W_ERROR_IS_OK(result)) {
2490 goto done;
2491 }
2492
2493 result = winreg_printer_write_multi_sz(tmp_ctx, winreg_pipe,
2494 &key_hnd, "Dependent Files",
2495 info8.dependent_files);
2496 if (!W_ERROR_IS_OK(result)) {
2497 goto done;
2498 }
2499
2500 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2501 &key_hnd, "Monitor",
2502 info8.monitor_name);
2503 if (!W_ERROR_IS_OK(result)) {
2504 goto done;
2505 }
2506
2507 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2508 &key_hnd, "Datatype",
2509 info8.default_datatype);
2510 if (!W_ERROR_IS_OK(result)) {
2511 goto done;
2512 }
2513
2514 result = winreg_printer_write_multi_sz(tmp_ctx, winreg_pipe,
2515 &key_hnd, "Previous Names",
2516 info8.previous_names);
2517 if (!W_ERROR_IS_OK(result)) {
2518 goto done;
2519 }
2520
2521 result = winreg_printer_write_date(tmp_ctx, winreg_pipe,
2522 &key_hnd, "DriverDate",
2523 info8.driver_date);
2524 if (!W_ERROR_IS_OK(result)) {
2525 goto done;
2526 }
2527
2528 result = winreg_printer_write_ver(tmp_ctx, winreg_pipe,
2529 &key_hnd, "DriverVersion",
2530 info8.driver_version);
2531 if (!W_ERROR_IS_OK(result)) {
2532 goto done;
2533 }
2534
2535 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2536 &key_hnd, "Manufacturer",
2537 info8.manufacturer_name);
2538 if (!W_ERROR_IS_OK(result)) {
2539 goto done;
2540 }
2541
2542 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2543 &key_hnd, "OEM URL",
2544 info8.manufacturer_url);
2545 if (!W_ERROR_IS_OK(result)) {
2546 goto done;
2547 }
2548
2549 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2550 &key_hnd, "HardwareID",
2551 info8.hardware_id);
2552 if (!W_ERROR_IS_OK(result)) {
2553 goto done;
2554 }
2555
2556 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2557 &key_hnd, "Provider",
2558 info8.provider);
2559 if (!W_ERROR_IS_OK(result)) {
2560 goto done;
2561 }
2562
2563 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2564 &key_hnd, "Print Processor",
2565 info8.print_processor);
2566 if (!W_ERROR_IS_OK(result)) {
2567 goto done;
2568 }
2569
2570 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2571 &key_hnd, "VendorSetup",
2572 info8.vendor_setup);
2573 if (!W_ERROR_IS_OK(result)) {
2574 goto done;
2575 }
2576
2577 result = winreg_printer_write_multi_sz(tmp_ctx, winreg_pipe,
2578 &key_hnd, "Color Profiles",
2579 info8.color_profiles);
2580 if (!W_ERROR_IS_OK(result)) {
2581 goto done;
2582 }
2583
2584 result = winreg_printer_write_sz(tmp_ctx, winreg_pipe,
2585 &key_hnd, "InfPath",
2586 info8.inf_path);
2587 if (!W_ERROR_IS_OK(result)) {
2588 goto done;
2589 }
2590
2591 result = winreg_printer_write_dword(tmp_ctx, winreg_pipe, &key_hnd,
2592 "PrinterDriverAttributes",
2593 info8.printer_driver_attributes);
2594 if (!W_ERROR_IS_OK(result)) {
2595 goto done;
2596 }
2597
2598 result = winreg_printer_write_multi_sz(tmp_ctx, winreg_pipe,
2599 &key_hnd, "CoreDependencies",
2600 info8.core_driver_dependencies);
2601 if (!W_ERROR_IS_OK(result)) {
2602 goto done;
2603 }
2604
2605 result = winreg_printer_write_date(tmp_ctx, winreg_pipe,
2606 &key_hnd, "MinInboxDriverVerDate",
2607 info8.min_inbox_driver_ver_date);
2608 if (!W_ERROR_IS_OK(result)) {
2609 goto done;
2610 }
2611
2612 result = winreg_printer_write_ver(tmp_ctx, winreg_pipe, &key_hnd,
2613 "MinInboxDriverVerVersion",
2614 info8.min_inbox_driver_ver_version);
2615 if (!W_ERROR_IS_OK(result)) {
2616 goto done;
2617 }
2618
2619 *driver_name = info8.driver_name;
2620 *driver_version = info8.version;
2621 result = WERR_OK;
2622 done:
2623 if (winreg_pipe != NULL) {
2624 if (is_valid_policy_hnd(&key_hnd)) {
2625 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2626 }
2627 if (is_valid_policy_hnd(&hive_hnd)) {
2628 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2629 }
2630 }
2631
2632 TALLOC_FREE(tmp_ctx);
2633 return result;
2634 }
2635
2636 WERROR winreg_get_driver(TALLOC_CTX *mem_ctx,
2637 struct auth_serversupplied_info *server_info,
2638 const char *architecture,
2639 const char *driver_name,
2640 uint32_t driver_version,
2641 struct spoolss_DriverInfo8 **_info8)
2642 {
2643 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2644 struct rpc_pipe_client *winreg_pipe = NULL;
2645 struct policy_handle hive_hnd, key_hnd;
2646 struct spoolss_DriverInfo8 i8, *info8;
2647 struct spoolss_PrinterEnumValues *enum_values = NULL;
2648 struct spoolss_PrinterEnumValues *v;
2649 uint32_t num_values = 0;
2650 TALLOC_CTX *tmp_ctx;
2651 WERROR result;
2652 uint32_t i;
2653
2654 ZERO_STRUCT(hive_hnd);
2655 ZERO_STRUCT(key_hnd);
2656 ZERO_STRUCT(i8);
2657
2658 tmp_ctx = talloc_new(mem_ctx);
2659 if (tmp_ctx == NULL) {
2660 return WERR_NOMEM;
2661 }
2662
2663 if (driver_version == DRIVER_ANY_VERSION) {
2664 /* look for Win2k first and then for NT4 */
2665 result = winreg_printer_opendriver(tmp_ctx,
2666 server_info,
2667 driver_name,
2668 architecture,
2669 3,
2670 access_mask, false,
2671 &winreg_pipe,
2672 &hive_hnd,
2673 &key_hnd);
2674 if (!W_ERROR_IS_OK(result)) {
2675 result = winreg_printer_opendriver(tmp_ctx,
2676 server_info,
2677 driver_name,
2678 architecture,
2679 2,
2680 access_mask, false,
2681 &winreg_pipe,
2682 &hive_hnd,
2683 &key_hnd);
2684 }
2685 } else {
2686 /* ok normal case */
2687 result = winreg_printer_opendriver(tmp_ctx,
2688 server_info,
2689 driver_name,
2690 architecture,
2691 driver_version,
2692 access_mask, false,
2693 &winreg_pipe,
2694 &hive_hnd,
2695 &key_hnd);
2696 }
2697 if (!W_ERROR_IS_OK(result)) {
2698 DEBUG(5, ("winreg_get_driver: "
2699 "Could not open driver key (%s,%s,%d): %s\n",
2700 driver_name, architecture,
2701 driver_version, win_errstr(result)));
2702 goto done;
2703 }
2704
2705 result = winreg_printer_enumvalues(tmp_ctx,
2706 winreg_pipe,
2707 &key_hnd,
2708 &num_values,
2709 &enum_values);
2710 if (!W_ERROR_IS_OK(result)) {
2711 DEBUG(0, ("winreg_get_driver: "
2712 "Could not enumerate values for (%s,%s,%d): %s\n",
2713 driver_name, architecture,
2714 driver_version, win_errstr(result)));
2715 goto done;
2716 }
2717
2718 info8 = talloc_zero(tmp_ctx, struct spoolss_DriverInfo8);
2719 if (!info8) {
2720 result = WERR_NOMEM;
2721 goto done;
2722 }
2723
2724 result = WERR_OK;
2725
2726 for (i = 0; i < num_values; i++) {
2727 const char *tmp_str;
2728
2729 v = &enum_values[i];
2730
2731 #define CHECK_ERROR(result) \
2732 if (W_ERROR_IS_OK(result)) continue; \
2733 if (W_ERROR_EQUAL(result, WERR_NOT_FOUND)) result = WERR_OK; \
2734 if (!W_ERROR_IS_OK(result)) break
2735
2736 result = winreg_enumval_to_dword(info8, v,
2737 "Version",
2738 &info8->version);
2739 CHECK_ERROR(result);
2740
2741 result = winreg_enumval_to_sz(info8, v,
2742 "Driver",
2743 &info8->driver_path);
2744 CHECK_ERROR(result);
2745
2746 result = winreg_enumval_to_sz(info8, v,
2747 "Data File",
2748 &info8->data_file);
2749 CHECK_ERROR(result);
2750
2751 result = winreg_enumval_to_sz(info8, v,
2752 "Configuration File",
2753 &info8->config_file);
2754 CHECK_ERROR(result);
2755
2756 result = winreg_enumval_to_sz(info8, v,
2757 "Help File",
2758 &info8->help_file);
2759 CHECK_ERROR(result);
2760
2761 result = winreg_enumval_to_multi_sz(info8, v,
2762 "Dependent Files",
2763 &info8->dependent_files);
2764 CHECK_ERROR(result);
2765
2766 result = winreg_enumval_to_sz(info8, v,
2767 "Monitor",
2768 &info8->monitor_name);
2769 CHECK_ERROR(result);
2770
2771 result = winreg_enumval_to_sz(info8, v,
2772 "Datatype",
2773 &info8->default_datatype);
2774 CHECK_ERROR(result);
2775
2776 result = winreg_enumval_to_multi_sz(info8, v,
2777 "Previous Names",
2778 &info8->previous_names);
2779 CHECK_ERROR(result);
2780
2781 result = winreg_enumval_to_sz(info8, v,
2782 "DriverDate",
2783 &tmp_str);
2784 if (W_ERROR_IS_OK(result)) {
2785 result = winreg_printer_date_to_NTTIME(tmp_str,
2786 &info8->driver_date);
2787 }
2788 CHECK_ERROR(result);
2789
2790 result = winreg_enumval_to_sz(info8, v,
2791 "DriverVersion",
2792 &tmp_str);
2793 if (W_ERROR_IS_OK(result)) {
2794 result = winreg_printer_ver_to_dword(tmp_str,
2795 &info8->driver_version);
2796 }
2797 CHECK_ERROR(result);
2798
2799 result = winreg_enumval_to_sz(info8, v,
2800 "Manufacturer",
2801 &info8->manufacturer_name);
2802 CHECK_ERROR(result);
2803
2804 result = winreg_enumval_to_sz(info8, v,
2805 "OEM URL",
2806 &info8->manufacturer_url);
2807 CHECK_ERROR(result);
2808
2809 result = winreg_enumval_to_sz(info8, v,
2810 "HardwareID",
2811 &info8->hardware_id);
2812 CHECK_ERROR(result);
2813
2814 result = winreg_enumval_to_sz(info8, v,
2815 "Provider",
2816 &info8->provider);
2817 CHECK_ERROR(result);
2818
2819 result = winreg_enumval_to_sz(info8, v,
2820 "Print Processor",
2821 &info8->print_processor);
2822 CHECK_ERROR(result);
2823
2824 result = winreg_enumval_to_sz(info8, v,
2825 "VendorSetup",
2826 &info8->vendor_setup);
2827 CHECK_ERROR(result);
2828
2829 result = winreg_enumval_to_multi_sz(info8, v,
2830 "Color Profiles",
2831 &info8->color_profiles);
2832 CHECK_ERROR(result);
2833
2834 result = winreg_enumval_to_sz(info8, v,
2835 "InfPath",
2836 &info8->inf_path);
2837 CHECK_ERROR(result);
2838
2839 result = winreg_enumval_to_dword(info8, v,
2840 "PrinterDriverAttributes",
2841 &info8->printer_driver_attributes);
2842 CHECK_ERROR(result);
2843
2844 result = winreg_enumval_to_multi_sz(info8, v,
2845 "CoreDependencies",
2846 &info8->core_driver_dependencies);
2847 CHECK_ERROR(result);
2848
2849 result = winreg_enumval_to_sz(info8, v,
2850 "MinInboxDriverVerDate",
2851 &tmp_str);
2852 if (W_ERROR_IS_OK(result)) {
2853 result = winreg_printer_date_to_NTTIME(tmp_str,
2854 &info8->min_inbox_driver_ver_date);
2855 }
2856 CHECK_ERROR(result);
2857
2858 result = winreg_enumval_to_sz(info8, v,
2859 "MinInboxDriverVerVersion",
2860 &tmp_str);
2861 if (W_ERROR_IS_OK(result)) {
2862 result = winreg_printer_ver_to_dword(tmp_str,
2863 &info8->min_inbox_driver_ver_version);
2864 }
2865 CHECK_ERROR(result);
2866 }
2867
2868 if (!W_ERROR_IS_OK(result)) {
2869 DEBUG(0, ("winreg_enumval_to_TYPE() failed "
2870 "for %s: %s\n", v->value_name,
2871 win_errstr(result)));
2872 goto done;
2873 }
2874
2875 *_info8 = talloc_steal(mem_ctx, info8);
2876 result = WERR_OK;
2877 done:
2878 if (winreg_pipe != NULL) {
2879 if (is_valid_policy_hnd(&key_hnd)) {
2880 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2881 }
2882 if (is_valid_policy_hnd(&hive_hnd)) {
2883 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2884 }
2885 }
2886
2887 TALLOC_FREE(tmp_ctx);
2888 return result;
2889 }
2890
2891 WERROR winreg_del_driver(TALLOC_CTX *mem_ctx,
2892 struct auth_serversupplied_info *server_info,
2893 struct spoolss_DriverInfo8 *info8,
2894 uint32_t version)
2895 {
2896 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2897 struct rpc_pipe_client *winreg_pipe = NULL;
2898 struct policy_handle hive_hnd, key_hnd;
2899 TALLOC_CTX *tmp_ctx;
2900 char *key_name;
2901 WERROR result;
2902
2903 ZERO_STRUCT(hive_hnd);
2904 ZERO_STRUCT(key_hnd);
2905
2906 tmp_ctx = talloc_new(mem_ctx);
2907 if (tmp_ctx == NULL) {
2908 return WERR_NOMEM;
2909 }
2910
2911 /* test that the key exists */
2912 result = winreg_printer_opendriver(tmp_ctx,
2913 server_info,
2914 info8->driver_name,
2915 info8->architecture,
2916 version,
2917 access_mask, false,
2918 &winreg_pipe,
2919 &hive_hnd,
2920 &key_hnd);
2921 if (!W_ERROR_IS_OK(result)) {
2922 /* key doesn't exist */
2923 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2924 result = WERR_OK;
2925 goto done;
2926 }
2927
2928 DEBUG(5, ("winreg_del_driver: "
2929 "Could not open driver (%s,%s,%u): %s\n",
2930 info8->driver_name, info8->architecture,
2931 version, win_errstr(result)));
2932 goto done;
2933 }
2934
2935
2936 if (is_valid_policy_hnd(&key_hnd)) {
2937 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2938 }
2939
2940 key_name = talloc_asprintf(tmp_ctx,
2941 "%s\\Environments\\%s\\Drivers\\Version-%u",
2942 TOP_LEVEL_CONTROL_KEY,
2943 info8->architecture, version);
2944 if (key_name == NULL) {
2945 result = WERR_NOMEM;
2946 goto done;
2947 }
2948
2949 result = winreg_printer_delete_subkeys(tmp_ctx,
2950 winreg_pipe,
2951 &hive_hnd,
2952 access_mask,
2953 key_name);
2954 if (!W_ERROR_IS_OK(result)) {
2955 DEBUG(0, ("winreg_del_driver: "
2956 "Could not open driver (%s,%s,%u): %s\n",
2957 info8->driver_name, info8->architecture,
2958 version, win_errstr(result)));
2959 goto done;
2960 }
2961
2962 result = WERR_OK;
2963 done:
2964 if (winreg_pipe != NULL) {
2965 if (is_valid_policy_hnd(&key_hnd)) {
2966 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2967 }
2968 if (is_valid_policy_hnd(&hive_hnd)) {
2969 rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2970 }
2971 }
2972
2973 TALLOC_FREE(tmp_ctx);
2974 return result;
2975 }