s3-spoolss: Add date and version winreg helpers.
[samba.git] / source3 / rpc_server / srv_spoolss_util.c
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         keyname = talloc_asprintf(tmp_ctx,
1704                                   "%s\\%s",
1705                                   path,
1706                                   key);
1707         if (keyname == NULL) {
1708                 result = WERR_NOMEM;
1709                 goto done;
1710         }
1711
1712         result = winreg_printer_delete_subkeys(tmp_ctx,
1713                                                winreg_pipe,
1714                                                &hive_hnd,
1715                                                access_mask,
1716                                                keyname);
1717         if (!W_ERROR_IS_OK(result)) {
1718                 DEBUG(0, ("winreg_delete_printer_key: Could not delete key %s: %s\n",
1719                           key, win_errstr(result)));
1720                 goto done;
1721         }
1722
1723 done:
1724         if (winreg_pipe != NULL) {
1725                 if (is_valid_policy_hnd(&key_hnd)) {
1726                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1727                 }
1728                 if (is_valid_policy_hnd(&hive_hnd)) {
1729                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1730                 }
1731         }
1732
1733         TALLOC_FREE(tmp_ctx);
1734         return result;
1735 }
1736
1737 WERROR winreg_printer_update_changeid(TALLOC_CTX *mem_ctx,
1738                                       struct auth_serversupplied_info *server_info,
1739                                       const char *printer)
1740 {
1741         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1742         struct rpc_pipe_client *winreg_pipe = NULL;
1743         struct policy_handle hive_hnd, key_hnd;
1744         char *path;
1745         WERROR result;
1746         TALLOC_CTX *tmp_ctx;
1747
1748         tmp_ctx = talloc_new(mem_ctx);
1749         if (tmp_ctx == NULL) {
1750                 return WERR_NOMEM;
1751         }
1752
1753         path = winreg_printer_data_keyname(tmp_ctx, printer);
1754         if (path == NULL) {
1755                 TALLOC_FREE(tmp_ctx);
1756                 return WERR_NOMEM;
1757         }
1758
1759         ZERO_STRUCT(hive_hnd);
1760         ZERO_STRUCT(key_hnd);
1761
1762         result = winreg_printer_openkey(tmp_ctx,
1763                                         server_info,
1764                                         &winreg_pipe,
1765                                         path,
1766                                         "",
1767                                         false,
1768                                         access_mask,
1769                                         &hive_hnd,
1770                                         &key_hnd);
1771         if (!W_ERROR_IS_OK(result)) {
1772                 DEBUG(0, ("winreg_printer_update_changeid: Could not open key %s: %s\n",
1773                           path, win_errstr(result)));
1774                 goto done;
1775         }
1776
1777         result = winreg_printer_write_dword(tmp_ctx,
1778                                             winreg_pipe,
1779                                             &key_hnd,
1780                                             "ChangeID",
1781                                             winreg_printer_rev_changeid());
1782         if (!W_ERROR_IS_OK(result)) {
1783                 goto done;
1784         }
1785
1786         result = WERR_OK;
1787 done:
1788         if (winreg_pipe != NULL) {
1789                 if (is_valid_policy_hnd(&key_hnd)) {
1790                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1791                 }
1792                 if (is_valid_policy_hnd(&hive_hnd)) {
1793                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1794                 }
1795         }
1796
1797         TALLOC_FREE(tmp_ctx);
1798         return result;
1799 }
1800
1801 WERROR winreg_printer_get_changeid(TALLOC_CTX *mem_ctx,
1802                                    struct auth_serversupplied_info *server_info,
1803                                    const char *printer,
1804                                    uint32_t *pchangeid)
1805 {
1806         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1807         struct rpc_pipe_client *winreg_pipe = NULL;
1808         struct policy_handle hive_hnd, key_hnd;
1809         uint32_t changeid = 0;
1810         char *path;
1811         WERROR result;
1812         TALLOC_CTX *tmp_ctx;
1813
1814         tmp_ctx = talloc_new(mem_ctx);
1815         if (tmp_ctx == NULL) {
1816                 return WERR_NOMEM;
1817         }
1818
1819         path = winreg_printer_data_keyname(tmp_ctx, printer);
1820         if (path == NULL) {
1821                 TALLOC_FREE(tmp_ctx);
1822                 return WERR_NOMEM;
1823         }
1824
1825         ZERO_STRUCT(hive_hnd);
1826         ZERO_STRUCT(key_hnd);
1827
1828         result = winreg_printer_openkey(tmp_ctx,
1829                                         server_info,
1830                                         &winreg_pipe,
1831                                         path,
1832                                         "",
1833                                         false,
1834                                         access_mask,
1835                                         &hive_hnd,
1836                                         &key_hnd);
1837         if (!W_ERROR_IS_OK(result)) {
1838                 DEBUG(0, ("winreg_printer_get_changeid: Could not open key %s: %s\n",
1839                           path, win_errstr(result)));
1840                 goto done;
1841         }
1842
1843         DEBUG(0, ("winreg_printer_get_changeid: get changeid from %s\n", path));
1844         result = winreg_printer_query_dword(tmp_ctx,
1845                                             winreg_pipe,
1846                                             &key_hnd,
1847                                             "ChangeID",
1848                                             &changeid);
1849         if (!W_ERROR_IS_OK(result)) {
1850                 goto done;
1851         }
1852
1853         if (pchangeid) {
1854                 *pchangeid = changeid;
1855         }
1856
1857         result = WERR_OK;
1858 done:
1859         if (winreg_pipe != NULL) {
1860                 if (is_valid_policy_hnd(&key_hnd)) {
1861                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1862                 }
1863                 if (is_valid_policy_hnd(&hive_hnd)) {
1864                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1865                 }
1866         }
1867
1868         TALLOC_FREE(tmp_ctx);
1869         return result;
1870 }
1871
1872 /*
1873  * The special behaviour of the spoolss forms is documented at the website:
1874  *
1875  * Managing Win32 Printserver Forms
1876  * http://unixwiz.net/techtips/winspooler-forms.html
1877  */
1878
1879 WERROR winreg_printer_addform1(TALLOC_CTX *mem_ctx,
1880                                struct auth_serversupplied_info *server_info,
1881                                struct spoolss_AddFormInfo1 *form)
1882 {
1883         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1884         struct rpc_pipe_client *winreg_pipe = NULL;
1885         struct policy_handle hive_hnd, key_hnd;
1886         struct winreg_String wvalue;
1887         DATA_BLOB blob;
1888         uint32_t num_info = 0;
1889         union spoolss_FormInfo *info = NULL;
1890         uint32_t i;
1891         WERROR result;
1892         NTSTATUS status;
1893         TALLOC_CTX *tmp_ctx;
1894
1895         tmp_ctx = talloc_new(mem_ctx);
1896         if (tmp_ctx == NULL) {
1897                 return WERR_NOMEM;
1898         }
1899
1900         ZERO_STRUCT(hive_hnd);
1901         ZERO_STRUCT(key_hnd);
1902
1903         result = winreg_printer_openkey(tmp_ctx,
1904                                         server_info,
1905                                         &winreg_pipe,
1906                                         TOP_LEVEL_CONTROL_FORMS_KEY,
1907                                         "",
1908                                         true,
1909                                         access_mask,
1910                                         &hive_hnd,
1911                                         &key_hnd);
1912         if (!W_ERROR_IS_OK(result)) {
1913                 DEBUG(0, ("winreg_printer_addform1: Could not open key %s: %s\n",
1914                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
1915                 goto done;
1916         }
1917
1918         result = winreg_printer_enumforms1(tmp_ctx, server_info, &num_info, &info);
1919         if (!W_ERROR_IS_OK(result)) {
1920                 DEBUG(0, ("winreg_printer_addform: Could not enum keys %s: %s\n",
1921                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
1922                 goto done;
1923         }
1924
1925         /* If form name already exists or is builtin return ALREADY_EXISTS */
1926         for (i = 0; i < num_info; i++) {
1927                 if (strequal(info[i].info1.form_name, form->form_name)) {
1928                         result = WERR_FILE_EXISTS;
1929                         goto done;
1930                 }
1931         }
1932
1933         wvalue.name = form->form_name;
1934
1935         blob = data_blob_talloc(tmp_ctx, NULL, 32);
1936         SIVAL(blob.data,  0, form->size.width);
1937         SIVAL(blob.data,  4, form->size.height);
1938         SIVAL(blob.data,  8, form->area.left);
1939         SIVAL(blob.data, 12, form->area.top);
1940         SIVAL(blob.data, 16, form->area.right);
1941         SIVAL(blob.data, 20, form->area.bottom);
1942         SIVAL(blob.data, 24, num_info + 1); /* FIXME */
1943         SIVAL(blob.data, 28, form->flags);
1944
1945         status = rpccli_winreg_SetValue(winreg_pipe,
1946                                         tmp_ctx,
1947                                         &key_hnd,
1948                                         wvalue,
1949                                         REG_BINARY,
1950                                         blob.data,
1951                                         blob.length,
1952                                         &result);
1953         if (!NT_STATUS_IS_OK(status)) {
1954                 DEBUG(0, ("winreg_printer_addform1: Could not set value %s: %s\n",
1955                           wvalue.name, nt_errstr(status)));
1956                 if (!W_ERROR_IS_OK(result)) {
1957                         goto done;
1958                 }
1959                 result = ntstatus_to_werror(status);
1960                 goto done;
1961         }
1962
1963         result = WERR_OK;
1964 done:
1965         if (winreg_pipe != NULL) {
1966                 if (is_valid_policy_hnd(&key_hnd)) {
1967                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
1968                 }
1969                 if (is_valid_policy_hnd(&hive_hnd)) {
1970                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
1971                 }
1972         }
1973
1974         TALLOC_FREE(info);
1975         TALLOC_FREE(tmp_ctx);
1976         return result;
1977 }
1978
1979 WERROR winreg_printer_enumforms1(TALLOC_CTX *mem_ctx,
1980                                  struct auth_serversupplied_info *server_info,
1981                                  uint32_t *pnum_info,
1982                                  union spoolss_FormInfo **pinfo)
1983 {
1984         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1985         struct rpc_pipe_client *winreg_pipe = NULL;
1986         struct policy_handle hive_hnd, key_hnd;
1987         union spoolss_FormInfo *info;
1988         struct spoolss_PrinterEnumValues *enum_values = NULL;
1989         uint32_t num_values = 0;
1990         uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
1991         uint32_t i;
1992         WERROR result;
1993         TALLOC_CTX *tmp_ctx;
1994
1995         tmp_ctx = talloc_new(mem_ctx);
1996         if (tmp_ctx == NULL) {
1997                 return WERR_NOMEM;
1998         }
1999
2000         ZERO_STRUCT(hive_hnd);
2001         ZERO_STRUCT(key_hnd);
2002
2003         result = winreg_printer_openkey(tmp_ctx,
2004                                         server_info,
2005                                         &winreg_pipe,
2006                                         TOP_LEVEL_CONTROL_FORMS_KEY,
2007                                         "",
2008                                         true,
2009                                         access_mask,
2010                                         &hive_hnd,
2011                                         &key_hnd);
2012         if (!W_ERROR_IS_OK(result)) {
2013                 /* key doesn't exist */
2014                 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2015                         result = WERR_OK;
2016                         goto done;
2017                 }
2018
2019                 DEBUG(0, ("winreg_printer_enumforms1: Could not open key %s: %s\n",
2020                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2021                 goto done;
2022         }
2023
2024         result = winreg_printer_enumvalues(tmp_ctx,
2025                                            winreg_pipe,
2026                                            &key_hnd,
2027                                            &num_values,
2028                                            &enum_values);
2029         if (!W_ERROR_IS_OK(result)) {
2030                 DEBUG(0, ("winreg_printer_enumforms1: Could not enumerate values in %s: %s\n",
2031                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2032                 goto done;
2033         }
2034
2035         info = TALLOC_ARRAY(tmp_ctx, union spoolss_FormInfo, num_builtin + num_values);
2036         if (info == NULL) {
2037                 result = WERR_NOMEM;
2038                 goto done;
2039         }
2040
2041         /* Enumerate BUILTIN forms */
2042         for (i = 0; i < num_builtin; i++) {
2043                 info[i].info1 = builtin_forms1[i];
2044         }
2045
2046         /* Enumerate registry forms */
2047         for (i = 0; i < num_values; i++) {
2048                 union spoolss_FormInfo val;
2049
2050                 if (enum_values[i].type != REG_BINARY ||
2051                     enum_values[i].data_length != 32) {
2052                         continue;
2053                 }
2054
2055                 val.info1.form_name = talloc_strdup(info, enum_values[i].value_name);
2056                 if (val.info1.form_name == NULL) {
2057                         result = WERR_NOMEM;
2058                         goto done;
2059                 }
2060
2061                 val.info1.size.width  = IVAL(enum_values[i].data->data,  0);
2062                 val.info1.size.height = IVAL(enum_values[i].data->data,  4);
2063                 val.info1.area.left   = IVAL(enum_values[i].data->data,  8);
2064                 val.info1.area.top    = IVAL(enum_values[i].data->data, 12);
2065                 val.info1.area.right  = IVAL(enum_values[i].data->data, 16);
2066                 val.info1.area.bottom = IVAL(enum_values[i].data->data, 20);
2067                 /* skip form index      IVAL(enum_values[i].data->data, 24)));*/
2068                 val.info1.flags       = IVAL(enum_values[i].data->data, 28);
2069
2070                 info[i + num_builtin] = val;
2071         }
2072
2073         *pnum_info = num_builtin + num_values;
2074         if (pinfo) {
2075                 *pinfo = talloc_move(mem_ctx, &info);
2076         }
2077
2078 done:
2079         if (winreg_pipe != NULL) {
2080                 if (is_valid_policy_hnd(&key_hnd)) {
2081                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2082                 }
2083                 if (is_valid_policy_hnd(&hive_hnd)) {
2084                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2085                 }
2086         }
2087
2088         TALLOC_FREE(enum_values);
2089         TALLOC_FREE(tmp_ctx);
2090         return result;
2091 }
2092
2093 WERROR winreg_printer_deleteform1(TALLOC_CTX *mem_ctx,
2094                                   struct auth_serversupplied_info *server_info,
2095                                   const char *form_name)
2096 {
2097         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2098         struct rpc_pipe_client *winreg_pipe = NULL;
2099         struct policy_handle hive_hnd, key_hnd;
2100         struct winreg_String wvalue;
2101         uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
2102         uint32_t i;
2103         WERROR result = WERR_OK;
2104         NTSTATUS status;
2105         TALLOC_CTX *tmp_ctx;
2106
2107         for (i = 0; i < num_builtin; i++) {
2108                 if (strequal(builtin_forms1[i].form_name, form_name)) {
2109                         return WERR_INVALID_PARAMETER;
2110                 }
2111         }
2112
2113         tmp_ctx = talloc_new(mem_ctx);
2114         if (tmp_ctx == NULL) {
2115                 return WERR_NOMEM;
2116         }
2117
2118         ZERO_STRUCT(hive_hnd);
2119         ZERO_STRUCT(key_hnd);
2120
2121         result = winreg_printer_openkey(tmp_ctx,
2122                                         server_info,
2123                                         &winreg_pipe,
2124                                         TOP_LEVEL_CONTROL_FORMS_KEY,
2125                                         "",
2126                                         false,
2127                                         access_mask,
2128                                         &hive_hnd,
2129                                         &key_hnd);
2130         if (!W_ERROR_IS_OK(result)) {
2131                 DEBUG(0, ("winreg_printer_deleteform1: Could not open key %s: %s\n",
2132                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2133                 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2134                         result = WERR_INVALID_FORM_NAME;
2135                 }
2136                 goto done;
2137         }
2138
2139         wvalue.name = form_name;
2140         status = rpccli_winreg_DeleteValue(winreg_pipe,
2141                                            tmp_ctx,
2142                                            &key_hnd,
2143                                            wvalue,
2144                                            &result);
2145         if (!NT_STATUS_IS_OK(status)) {
2146                 /* If the value doesn't exist, return WERR_INVALID_FORM_NAME */
2147                 if (W_ERROR_EQUAL(result, WERR_BADFILE)) {
2148                         result = WERR_INVALID_FORM_NAME;
2149                         goto done;
2150                 }
2151                 DEBUG(0, ("winreg_printer_delteform1: Could not delete value %s: %s\n",
2152                           wvalue.name, nt_errstr(status)));
2153                 if (!W_ERROR_IS_OK(result)) {
2154                         goto done;
2155                 }
2156                 result = ntstatus_to_werror(status);
2157                 goto done;
2158         }
2159
2160         result = WERR_OK;
2161 done:
2162         if (winreg_pipe != NULL) {
2163                 if (is_valid_policy_hnd(&key_hnd)) {
2164                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2165                 }
2166                 if (is_valid_policy_hnd(&hive_hnd)) {
2167                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2168                 }
2169         }
2170
2171         TALLOC_FREE(tmp_ctx);
2172         return result;
2173 }
2174
2175 WERROR winreg_printer_setform1(TALLOC_CTX *mem_ctx,
2176                                struct auth_serversupplied_info *server_info,
2177                                const char *form_name,
2178                                struct spoolss_AddFormInfo1 *form)
2179 {
2180         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2181         struct rpc_pipe_client *winreg_pipe = NULL;
2182         struct policy_handle hive_hnd, key_hnd;
2183         struct winreg_String wvalue;
2184         DATA_BLOB blob;
2185         uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
2186         uint32_t i;
2187         WERROR result;
2188         NTSTATUS status;
2189         TALLOC_CTX *tmp_ctx = NULL;
2190
2191         for (i = 0; i < num_builtin; i++) {
2192                 if (strequal(builtin_forms1[i].form_name, form->form_name)) {
2193                         result = WERR_INVALID_PARAM;
2194                         goto done;
2195                 }
2196         }
2197
2198         tmp_ctx = talloc_new(mem_ctx);
2199         if (tmp_ctx == NULL) {
2200                 return WERR_NOMEM;
2201         }
2202
2203         ZERO_STRUCT(hive_hnd);
2204         ZERO_STRUCT(key_hnd);
2205
2206         result = winreg_printer_openkey(tmp_ctx,
2207                                         server_info,
2208                                         &winreg_pipe,
2209                                         TOP_LEVEL_CONTROL_FORMS_KEY,
2210                                         "",
2211                                         true,
2212                                         access_mask,
2213                                         &hive_hnd,
2214                                         &key_hnd);
2215         if (!W_ERROR_IS_OK(result)) {
2216                 DEBUG(0, ("winreg_printer_setform1: Could not open key %s: %s\n",
2217                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2218                 goto done;
2219         }
2220
2221         /* If form_name != form->form_name then we renamed the form */
2222         if (strequal(form_name, form->form_name)) {
2223                 result = winreg_printer_deleteform1(tmp_ctx, server_info, form_name);
2224                 if (!W_ERROR_IS_OK(result)) {
2225                         DEBUG(0, ("winreg_printer_setform1: Could not open key %s: %s\n",
2226                                   TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2227                         goto done;
2228                 }
2229         }
2230
2231         wvalue.name = form->form_name;
2232
2233         blob = data_blob_talloc(tmp_ctx, NULL, 32);
2234         SIVAL(blob.data,  0, form->size.width);
2235         SIVAL(blob.data,  4, form->size.height);
2236         SIVAL(blob.data,  8, form->area.left);
2237         SIVAL(blob.data, 12, form->area.top);
2238         SIVAL(blob.data, 16, form->area.right);
2239         SIVAL(blob.data, 20, form->area.bottom);
2240         SIVAL(blob.data, 24, 42);
2241         SIVAL(blob.data, 28, form->flags);
2242
2243         status = rpccli_winreg_SetValue(winreg_pipe,
2244                                         tmp_ctx,
2245                                         &key_hnd,
2246                                         wvalue,
2247                                         REG_BINARY,
2248                                         blob.data,
2249                                         blob.length,
2250                                         &result);
2251         if (!NT_STATUS_IS_OK(status)) {
2252                 DEBUG(0, ("winreg_printer_setform1: Could not set value %s: %s\n",
2253                           wvalue.name, nt_errstr(status)));
2254                 if (!W_ERROR_IS_OK(result)) {
2255                         goto done;
2256                 }
2257                 result = ntstatus_to_werror(status);
2258                 goto done;
2259         }
2260
2261         result = WERR_OK;
2262 done:
2263         if (winreg_pipe != NULL) {
2264                 if (is_valid_policy_hnd(&key_hnd)) {
2265                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2266                 }
2267                 if (is_valid_policy_hnd(&hive_hnd)) {
2268                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2269                 }
2270         }
2271
2272         TALLOC_FREE(tmp_ctx);
2273         return result;
2274 }
2275
2276 WERROR winreg_printer_getform1(TALLOC_CTX *mem_ctx,
2277                                struct auth_serversupplied_info *server_info,
2278                                const char *form_name,
2279                                struct spoolss_FormInfo1 *r)
2280 {
2281         uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2282         struct rpc_pipe_client *winreg_pipe = NULL;
2283         struct policy_handle hive_hnd, key_hnd;
2284         struct winreg_String wvalue;
2285         enum winreg_Type type_in;
2286         uint8_t *data_in;
2287         uint32_t data_in_size = 0;
2288         uint32_t value_len = 0;
2289         uint32_t num_builtin = ARRAY_SIZE(builtin_forms1);
2290         uint32_t i;
2291         WERROR result;
2292         NTSTATUS status;
2293         TALLOC_CTX *tmp_ctx;
2294
2295         /* check builtin forms first */
2296         for (i = 0; i < num_builtin; i++) {
2297                 if (strequal(builtin_forms1[i].form_name, form_name)) {
2298                         *r = builtin_forms1[i];
2299                         return WERR_OK;
2300                 }
2301         }
2302
2303         tmp_ctx = talloc_new(mem_ctx);
2304         if (tmp_ctx == NULL) {
2305                 return WERR_NOMEM;
2306         }
2307
2308         ZERO_STRUCT(hive_hnd);
2309         ZERO_STRUCT(key_hnd);
2310
2311         result = winreg_printer_openkey(tmp_ctx,
2312                                         server_info,
2313                                         &winreg_pipe,
2314                                         TOP_LEVEL_CONTROL_FORMS_KEY,
2315                                         "",
2316                                         true,
2317                                         access_mask,
2318                                         &hive_hnd,
2319                                         &key_hnd);
2320         if (!W_ERROR_IS_OK(result)) {
2321                 DEBUG(0, ("winreg_printer_getform1: Could not open key %s: %s\n",
2322                           TOP_LEVEL_CONTROL_FORMS_KEY, win_errstr(result)));
2323                 goto done;
2324         }
2325
2326         wvalue.name = form_name;
2327
2328         /*
2329          * call QueryValue once with data == NULL to get the
2330          * needed memory size to be allocated, then allocate
2331          * data buffer and call again.
2332          */
2333         status = rpccli_winreg_QueryValue(winreg_pipe,
2334                                           tmp_ctx,
2335                                           &key_hnd,
2336                                           &wvalue,
2337                                           &type_in,
2338                                           NULL,
2339                                           &data_in_size,
2340                                           &value_len,
2341                                           &result);
2342         if (!NT_STATUS_IS_OK(status)) {
2343                 DEBUG(0, ("winreg_printer_getform1: Could not query value %s: %s\n",
2344                           wvalue.name, nt_errstr(status)));
2345                 if (!W_ERROR_IS_OK(result)) {
2346                         goto done;
2347                 }
2348                 result = ntstatus_to_werror(status);
2349                 goto done;
2350         }
2351
2352         data_in = (uint8_t *) TALLOC(tmp_ctx, data_in_size);
2353         if (data_in == NULL) {
2354                 result = WERR_NOMEM;
2355                 goto done;
2356         }
2357         value_len = 0;
2358
2359         status = rpccli_winreg_QueryValue(winreg_pipe,
2360                                           tmp_ctx,
2361                                           &key_hnd,
2362                                           &wvalue,
2363                                           &type_in,
2364                                           data_in,
2365                                           &data_in_size,
2366                                           &value_len,
2367                                           &result);
2368         if (!NT_STATUS_IS_OK(status)) {
2369                 DEBUG(0, ("winreg_printer_getform1: Could not query value %s: %s\n",
2370                           wvalue.name, nt_errstr(status)));
2371                 if (!W_ERROR_IS_OK(result)) {
2372                         goto done;
2373                 }
2374                 result = ntstatus_to_werror(status);
2375                 goto done;
2376         }
2377
2378         r->form_name = talloc_strdup(mem_ctx, form_name);
2379         if (r->form_name == NULL) {
2380                 result = WERR_NOMEM;
2381                 goto done;
2382         }
2383
2384         r->size.width  = IVAL(data_in,  0);
2385         r->size.height = IVAL(data_in,  4);
2386         r->area.left   = IVAL(data_in,  8);
2387         r->area.top    = IVAL(data_in, 12);
2388         r->area.right  = IVAL(data_in, 16);
2389         r->area.bottom = IVAL(data_in, 20);
2390         /* skip index    IVAL(data_in, 24)));*/
2391         r->flags       = IVAL(data_in, 28);
2392
2393         result = WERR_OK;
2394 done:
2395         if (winreg_pipe != NULL) {
2396                 if (is_valid_policy_hnd(&key_hnd)) {
2397                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &key_hnd, NULL);
2398                 }
2399                 if (is_valid_policy_hnd(&hive_hnd)) {
2400                         rpccli_winreg_CloseKey(winreg_pipe, tmp_ctx, &hive_hnd, NULL);
2401                 }
2402         }
2403
2404         TALLOC_FREE(tmp_ctx);
2405         return result;
2406 }
2407