adding "Service Control Manager" commands to rpcclient.
[samba.git] / source / rpc_parse / parse_svc.c
1
2 /* 
3  *  Unix SMB/Netbios implementation.
4  *  Version 1.9.
5  *  RPC Pipe client / server routines
6  *  Copyright (C) Andrew Tridgell              1992-1997,
7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
8  *  Copyright (C) Paul Ashton                       1997.
9  *  
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25
26 #include "includes.h"
27
28 extern int DEBUGLEVEL;
29
30 /*******************************************************************
31  make_svc_q_open_sc_man
32  ********************************************************************/
33 void make_svc_q_open_sc_man(SVC_Q_OPEN_SC_MAN *q_u,
34                                 char *server, char *database,
35                                 uint32 des_access)  
36 {
37         DEBUG(5,("make_svc_q_open_sc_man\n"));
38
39         make_buf_unistr2(&(q_u->uni_srv_name), &(q_u->ptr_srv_name), server);
40         make_buf_unistr2(&(q_u->uni_db_name ), &(q_u->ptr_db_name), database);
41         q_u->des_access = des_access;
42
43 }
44
45 /*******************************************************************
46 reads or writes a SVC_Q_OPEN_SC_MAN structure.
47 ********************************************************************/
48 void svc_io_q_open_sc_man(char *desc, SVC_Q_OPEN_SC_MAN *q_u, prs_struct *ps, int depth)
49 {
50         if (q_u == NULL) return;
51
52         prs_debug(ps, depth, desc, "svc_io_q_open_sc_man");
53         depth++;
54
55         prs_align(ps);
56
57         prs_uint32("ptr_srv_name", ps, depth, &(q_u->ptr_srv_name));
58         smb_io_unistr2("", &(q_u->uni_srv_name), q_u->ptr_srv_name, ps, depth); 
59         prs_align(ps);
60
61         prs_uint32("ptr_db_name", ps, depth, &(q_u->ptr_db_name));
62         smb_io_unistr2("", &(q_u->uni_db_name), q_u->ptr_db_name, ps, depth); 
63         prs_align(ps);
64
65         prs_uint32("des_access", ps, depth, &(q_u->des_access));
66         prs_align(ps);
67 }
68
69 /*******************************************************************
70  make_svc_r_open_sc_man
71  ********************************************************************/
72 void make_svc_r_open_sc_man(SVC_R_OPEN_SC_MAN *r_u, POLICY_HND *hnd,
73                                 uint32 status)  
74 {
75         DEBUG(5,("make_svc_r_unknown_0: %d\n", __LINE__));
76
77         memcpy(&(r_u->pol), hnd, sizeof(r_u->pol));
78         r_u->status = status;
79 }
80
81 /*******************************************************************
82 reads or writes a structure.
83 ********************************************************************/
84 void svc_io_r_open_sc_man(char *desc,  SVC_R_OPEN_SC_MAN *r_u, prs_struct *ps, int depth)
85 {
86         if (r_u == NULL) return;
87
88         prs_debug(ps, depth, desc, "svc_io_r_open_sc_man");
89         depth++;
90
91         prs_align(ps);
92
93         smb_io_pol_hnd("", &(r_u->pol), ps, depth);
94
95         prs_uint32("status      ", ps, depth, &(r_u->status));
96 }
97
98 /*******************************************************************
99 makes an SVC_Q_ENUM_SVCS_STATUS structure.
100 ********************************************************************/
101 void make_svc_q_enum_svcs_status(SVC_Q_ENUM_SVCS_STATUS *q_c, POLICY_HND *hnd,
102                                 uint32 service_type, uint32 service_state,
103                                 uint32 buf_size, uint32 resume_hnd )
104 {
105         if (q_c == NULL || hnd == NULL) return;
106
107         DEBUG(5,("make_svc_q_enum_svcs_status\n"));
108
109         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
110         q_c->service_type = service_type;
111         q_c->service_state = service_state;
112         q_c->buf_size = buf_size;
113         make_enum_hnd(&q_c->resume_hnd, resume_hnd);
114 }
115
116 /*******************************************************************
117 reads or writes a structure.
118 ********************************************************************/
119 void svc_io_q_enum_svcs_status(char *desc,  SVC_Q_ENUM_SVCS_STATUS *q_u, prs_struct *ps, int depth)
120 {
121         if (q_u == NULL) return;
122
123         prs_debug(ps, depth, desc, "svc_io_q_enum_svcs_status");
124         depth++;
125
126         prs_align(ps);
127
128         smb_io_pol_hnd("", &(q_u->pol), ps, depth); 
129         prs_align(ps);
130
131         prs_uint32("service_type ", ps, depth, &(q_u->service_type ));
132         prs_uint32("service_state", ps, depth, &(q_u->service_state));
133         prs_uint32("buf_size     ", ps, depth, &(q_u->buf_size     ));
134         smb_io_enum_hnd("resume_hnd", &(q_u->resume_hnd), ps, depth); 
135 }
136
137 /*******************************************************************
138 makes an SVC_Q_CLOSE structure.
139 ********************************************************************/
140 void make_svc_q_close(SVC_Q_CLOSE *q_c, POLICY_HND *hnd)
141 {
142         if (q_c == NULL || hnd == NULL) return;
143
144         DEBUG(5,("make_svc_q_close\n"));
145
146         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
147 }
148
149 /*******************************************************************
150 reads or writes a structure.
151 ********************************************************************/
152 void svc_io_q_close(char *desc,  SVC_Q_CLOSE *q_u, prs_struct *ps, int depth)
153 {
154         if (q_u == NULL) return;
155
156         prs_debug(ps, depth, desc, "svc_io_q_close");
157         depth++;
158
159         prs_align(ps);
160
161         smb_io_pol_hnd("", &(q_u->pol), ps, depth); 
162         prs_align(ps);
163 }
164
165 /*******************************************************************
166 reads or writes a structure.
167 ********************************************************************/
168 void svc_io_r_close(char *desc,  SVC_R_CLOSE *r_u, prs_struct *ps, int depth)
169 {
170         if (r_u == NULL) return;
171
172         prs_debug(ps, depth, desc, "svc_io_r_close");
173         depth++;
174
175         prs_align(ps);
176
177         smb_io_pol_hnd("", &(r_u->pol), ps, depth); 
178         prs_align(ps);
179
180         prs_uint32("status", ps, depth, &(r_u->status));
181 }
182
183 #if 0
184 /*******************************************************************
185 reads or writes a SEC_DESC_BUF structure.
186 ********************************************************************/
187 void sec_io_desc_buf(char *desc, SEC_DESC_BUF *sec, prs_struct *ps, int depth)
188 {
189         uint32 off_len;
190         uint32 old_offset;
191         uint32 size;
192
193         if (sec == NULL) return;
194
195         prs_debug(ps, depth, desc, "sec_io_desc_buf");
196         depth++;
197
198         prs_align(ps);
199         
200         prs_uint32_pre("max_len", ps, depth, &(sec->max_len), &off_max_len);
201
202         old_offset = ps->offset;
203
204         if (sec->len != 0 && ps->io)
205         {
206                 /* reading */
207                 sec->sec = malloc(sizeof(*sec->sec));
208                 ZERO_STRUCTP(sec->sec);
209
210                 if (sec->sec == NULL)
211                 {
212                         DEBUG(0,("INVALID SEC_DESC\n"));
213                         ps->offset = 0xfffffffe;
214                         return;
215                 }
216         }
217
218         /* reading, length is non-zero; writing, descriptor is non-NULL */
219         if ((sec->len != 0 || (!ps->io)) && sec->sec != NULL)
220         {
221                 sec_io_desc("sec   ", sec->sec, ps, depth);
222         }
223
224         size = ps->offset - old_offset;
225         prs_uint32_post("max_len", ps, depth, &(sec->max_len), off_max_len, size == 0 ? sec->max_len : size);
226 }
227 #endif