9c1f0f333598ddabc253b44e65d91d8801628efe
[samba.git] / source3 / 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  make_svc_q_open_service
100  ********************************************************************/
101 void make_svc_q_open_service(SVC_Q_OPEN_SERVICE *q_u,
102                                 POLICY_HND *hnd,
103                                 char *server,
104                                 uint32 des_access)  
105 {
106         DEBUG(5,("make_svc_q_open_service\n"));
107
108         memcpy(&(q_u->scman_pol), hnd, sizeof(q_u->scman_pol));
109         make_unistr2(&(q_u->uni_svc_name), server, strlen(server)+1);
110         q_u->des_access = des_access;
111
112 }
113
114 /*******************************************************************
115 reads or writes a SVC_Q_OPEN_SERVICE structure.
116 ********************************************************************/
117 void svc_io_q_open_service(char *desc, SVC_Q_OPEN_SERVICE *q_u, prs_struct *ps, int depth)
118 {
119         if (q_u == NULL) return;
120
121         prs_debug(ps, depth, desc, "svc_io_q_open_service");
122         depth++;
123
124         prs_align(ps);
125
126         smb_io_pol_hnd("", &(q_u->scman_pol), ps, depth);
127         prs_align(ps);
128
129         smb_io_unistr2("", &(q_u->uni_svc_name), 1, ps, depth); 
130         prs_align(ps);
131
132         prs_uint32("des_access", ps, depth, &(q_u->des_access));
133         prs_align(ps);
134 }
135
136 /*******************************************************************
137  make_svc_r_open_service
138  ********************************************************************/
139 void make_svc_r_open_service(SVC_R_OPEN_SERVICE *r_u, POLICY_HND *hnd,
140                                 uint32 status)  
141 {
142         DEBUG(5,("make_svc_r_unknown_0: %d\n", __LINE__));
143
144         memcpy(&(r_u->pol), hnd, sizeof(r_u->pol));
145         r_u->status = status;
146 }
147
148 /*******************************************************************
149 reads or writes a structure.
150 ********************************************************************/
151 void svc_io_r_open_service(char *desc,  SVC_R_OPEN_SERVICE *r_u, prs_struct *ps, int depth)
152 {
153         if (r_u == NULL) return;
154
155         prs_debug(ps, depth, desc, "svc_io_r_open_service");
156         depth++;
157
158         prs_align(ps);
159
160         smb_io_pol_hnd("", &(r_u->pol), ps, depth);
161
162         prs_uint32("status      ", ps, depth, &(r_u->status));
163 }
164
165 /*******************************************************************
166  make_svc_query_svc_cfg
167  ********************************************************************/
168 void make_svc_query_svc_cfg(QUERY_SERVICE_CONFIG *q_u,
169                                 uint32 service_type, uint32 start_type,
170                                 uint32 error_control,
171                                 char* bin_path_name, char* load_order_grp, 
172                                 uint32 tag_id,
173                                 char* dependencies, char* service_start_name,
174                                 char* disp_name)
175 {
176         DEBUG(5,("make_svc_query_svc_cfg\n"));
177
178         q_u->service_type = service_type;
179         q_u->start_type = start_type;
180         q_u->error_control = error_control;
181         make_buf_unistr2(&(q_u->uni_bin_path_name     ), &(q_u->ptr_bin_path_name     ), bin_path_name     );
182         make_buf_unistr2(&(q_u->uni_load_order_grp    ), &(q_u->ptr_load_order_grp    ), load_order_grp    );
183         q_u->tag_id = tag_id;
184         make_buf_unistr2(&(q_u->uni_dependencies      ), &(q_u->ptr_dependencies      ), dependencies      );
185         make_buf_unistr2(&(q_u->uni_service_start_name), &(q_u->ptr_service_start_name), service_start_name);
186         make_buf_unistr2(&(q_u->uni_display_name      ), &(q_u->ptr_display_name      ), disp_name         );
187 }
188
189 /*******************************************************************
190 reads or writes a QUERY_SERVICE_CONFIG structure.
191 ********************************************************************/
192 void svc_io_query_svc_cfg(char *desc, QUERY_SERVICE_CONFIG *q_u, prs_struct *ps, int depth)
193 {
194         if (q_u == NULL) return;
195
196         prs_debug(ps, depth, desc, "svc_io_query_svc_cfg");
197         depth++;
198
199         prs_align(ps);
200
201         prs_uint32("service_type          ", ps, depth, &(q_u->service_type          ));
202         prs_uint32("start_type            ", ps, depth, &(q_u->start_type            ));
203         prs_uint32("error_control         ", ps, depth, &(q_u->error_control         ));
204         prs_uint32("ptr_bin_path_name     ", ps, depth, &(q_u->ptr_bin_path_name     ));
205         prs_uint32("ptr_load_order_grp    ", ps, depth, &(q_u->ptr_load_order_grp    ));
206         prs_uint32("tag_id                ", ps, depth, &(q_u->tag_id                ));
207         prs_uint32("ptr_dependencies      ", ps, depth, &(q_u->ptr_dependencies      ));
208         prs_uint32("ptr_service_start_name", ps, depth, &(q_u->ptr_service_start_name));
209         prs_uint32("ptr_display_name      ", ps, depth, &(q_u->ptr_display_name      ));
210
211         smb_io_unistr2("uni_bin_path_name     ", &(q_u->uni_bin_path_name     ), q_u->ptr_bin_path_name     , ps, depth); 
212         prs_align(ps);
213         smb_io_unistr2("uni_load_order_grp    ", &(q_u->uni_load_order_grp    ), q_u->ptr_load_order_grp    , ps, depth); 
214         prs_align(ps);
215         smb_io_unistr2("uni_dependencies      ", &(q_u->uni_dependencies      ), q_u->ptr_dependencies      , ps, depth); 
216         prs_align(ps);
217         smb_io_unistr2("uni_service_start_name", &(q_u->uni_service_start_name), q_u->ptr_service_start_name, ps, depth); 
218         prs_align(ps);
219         smb_io_unistr2("uni_display_name      ", &(q_u->uni_display_name      ), q_u->ptr_display_name      , ps, depth); 
220         prs_align(ps);
221 }
222
223 /*******************************************************************
224 makes an SVC_Q_ENUM_SVCS_STATUS structure.
225 ********************************************************************/
226 void make_svc_q_enum_svcs_status(SVC_Q_ENUM_SVCS_STATUS *q_c, POLICY_HND *hnd,
227                                 uint32 service_type, uint32 service_state,
228                                 uint32 buf_size, uint32 resume_hnd )
229 {
230         if (q_c == NULL || hnd == NULL) return;
231
232         DEBUG(5,("make_svc_q_enum_svcs_status\n"));
233
234         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
235         q_c->service_type = service_type;
236         q_c->service_state = service_state;
237         q_c->buf_size = buf_size;
238         make_enum_hnd(&q_c->resume_hnd, resume_hnd);
239 }
240
241 /*******************************************************************
242 reads or writes a structure.
243 ********************************************************************/
244 void svc_io_q_enum_svcs_status(char *desc,  SVC_Q_ENUM_SVCS_STATUS *q_u, prs_struct *ps, int depth)
245 {
246         if (q_u == NULL) return;
247
248         prs_debug(ps, depth, desc, "svc_io_q_enum_svcs_status");
249         depth++;
250
251         prs_align(ps);
252
253         smb_io_pol_hnd("", &(q_u->pol), ps, depth); 
254         prs_align(ps);
255
256         prs_uint32("service_type ", ps, depth, &(q_u->service_type ));
257         prs_uint32("service_state", ps, depth, &(q_u->service_state));
258         prs_uint32("buf_size     ", ps, depth, &(q_u->buf_size     ));
259         smb_io_enum_hnd("resume_hnd", &(q_u->resume_hnd), ps, depth); 
260 }
261
262 /*******************************************************************
263 makes an SVC_R_ENUM_SVCS_STATUS structure.
264 ********************************************************************/
265 void make_svc_r_enum_svcs_status(SVC_R_ENUM_SVCS_STATUS *r_c, 
266                                 ENUM_SRVC_STATUS *svcs, uint32 more_buf_size,
267                                 uint32 num_svcs, uint32 resume_hnd,
268                                 uint32 dos_status)
269 {
270         if (r_c == NULL) return;
271
272         DEBUG(5,("make_svc_r_enum_svcs_status\n"));
273
274         r_c->svcs          = svcs;
275         r_c->more_buf_size = more_buf_size;
276         r_c->num_svcs      = num_svcs;
277         make_enum_hnd(&r_c->resume_hnd, resume_hnd);
278         r_c->dos_status = dos_status;
279 }
280
281 /*******************************************************************
282 reads or writes a SVC_R_ENUM_SVCS_STATUS structure.
283
284 this is another wierd structure.  WHY oh WHY can the microsoft teams
285 not COMMUNICATE and get some CONSISTENCY TO THEIR DATA STRUCTURES!
286 ARGH!
287
288 ********************************************************************/
289 void svc_io_r_enum_svcs_status(char *desc, SVC_R_ENUM_SVCS_STATUS *svc, prs_struct *ps, int depth)
290 {
291         int i;
292         if (svc == NULL) return;
293
294         prs_debug(ps, depth, desc, "svc_io_r_enum_svcs_status");
295         depth++;
296
297         prs_align(ps);
298         
299         /*
300          * format is actually as laid out in SVC_R_ENUM_SVCS_STATUS.
301          * the reason for all the jumping about, which is horrible
302          * and can be avoided, is due to the use of offsets instead
303          * of pointers.
304          *
305          * if i ever find out that these offsets are in fact non-zero
306          * tokens just like pointer-tokens, i am going to go MAD.
307          */
308
309         if (ps->io)
310         {
311                 /* reading */
312
313                 uint32 buf_offset;
314                 uint32 new_offset;
315
316                 prs_uint32("buf_size", ps, depth, &(svc->buf_size));
317
318                 buf_offset = ps->offset;
319                 ps->offset = buf_offset + svc->buf_size;
320
321                 prs_uint32("more_buf_size", ps, depth, &(svc->more_buf_size));
322                 prs_uint32("num_svcs", ps, depth, &(svc->num_svcs));
323                 smb_io_enum_hnd("resume_hnd", &(svc->resume_hnd), ps, depth); 
324                 prs_uint32("dos_status", ps, depth, &(svc->dos_status));
325
326                 new_offset = ps->offset;
327                 ps->offset = buf_offset;
328
329                 svc->svcs = Realloc(NULL, svc->num_svcs * sizeof(ENUM_SRVC_STATUS));
330
331                 if (svc->svcs == NULL)
332                 {
333                         DEBUG(0,("svc_io_r_enum_svcs_status: Realloc failed\n"));
334                         ps->offset = 0x7fffffff;
335                         return;
336                 }
337
338                 bzero(svc->svcs, svc->num_svcs * sizeof(ENUM_SRVC_STATUS));
339
340                 for (i = 0; i < svc->num_svcs; i++)
341                 {
342                         fstring name;
343                         uint32 old_offset;
344                         uint32 srvc_offset;
345                         uint32 disp_offset;
346
347                         prs_uint32("srvc_offset", ps, depth, &srvc_offset);
348                         prs_uint32("disp_offset", ps, depth, &disp_offset);
349                         svc_io_svc_status("status", &svc->svcs[i].status, ps, depth); 
350
351                         old_offset = ps->offset;
352
353                         ps->offset = buf_offset + srvc_offset;
354                         slprintf(name, sizeof(name)-1, "srvc[%02d]", i);
355                         smb_io_unistr(name, &svc->svcs[i].uni_srvc_name, ps, depth);
356
357                         ps->offset = buf_offset + disp_offset;
358                         slprintf(name, sizeof(name)-1, "disp[%02d]", i);
359                         smb_io_unistr(name, &svc->svcs[i].uni_disp_name, ps, depth);
360
361                         ps->offset = old_offset;
362                 }
363
364                 ps->offset = new_offset;
365         }
366         else
367         {
368                 /* writing */
369
370                 uint32 buf_offset;
371                 uint32 old_buf_offset;
372                 uint32 srvc_offset = 9 * sizeof(uint32) * svc->num_svcs;
373
374                 prs_uint32_pre("buf_size", ps, depth, &svc->buf_size, &buf_offset);
375                 old_buf_offset = ps->offset;
376
377                 srvc_offset += old_buf_offset;
378
379                 if (svc->svcs == NULL)
380                 {
381                         return;
382                 }
383
384                 for (i = 0; i < svc->num_svcs; i++)
385                 {
386                         fstring name;
387                         uint32 old_offset;
388
389                         /*
390                          * store unicode string offset and unicode string
391                          */
392
393                         srvc_offset -= old_buf_offset;
394                         prs_uint32("srvc_offset", ps, depth, &srvc_offset);
395                         srvc_offset += old_buf_offset;
396
397                         slprintf(name, sizeof(name)-1, "srvc[%02d]", i);
398
399                         old_offset = ps->offset;
400                         ps->offset = srvc_offset;
401                         smb_io_unistr(name, &svc->svcs[i].uni_srvc_name, ps, depth);
402                         srvc_offset = ps->offset;
403                         ps->offset = old_offset;
404
405                         /*
406                          * store unicode string offset and unicode string
407                          */
408
409                         srvc_offset -= old_buf_offset;
410                         prs_uint32("disp_offset", ps, depth, &srvc_offset);
411                         srvc_offset += old_buf_offset;
412
413                         slprintf(name, sizeof(name)-1, "disp[%02d]", i);
414
415                         old_offset = ps->offset;
416                         ps->offset = srvc_offset;
417                         smb_io_unistr(name, &svc->svcs[i].uni_disp_name, ps, depth);
418                         srvc_offset = ps->offset;
419                         ps->offset = old_offset;
420
421                         /*
422                          * store status info
423                          */
424
425                         svc_io_svc_status("status", &svc->svcs[i].status, ps, depth); 
426                 }
427
428                 prs_uint32_post("buf_size", ps, depth, &svc->buf_size, buf_offset, srvc_offset - buf_offset - sizeof(uint32));
429
430                 ps->offset = srvc_offset;
431
432                 prs_uint32("more_buf_size", ps, depth, &(svc->more_buf_size));
433                 prs_uint32("num_svcs", ps, depth, &(svc->num_svcs));
434                 smb_io_enum_hnd("resume_hnd", &(svc->resume_hnd), ps, depth); 
435                 prs_uint32("dos_status", ps, depth, &(svc->dos_status));
436         }
437 }
438
439 /*******************************************************************
440 reads or writes a structure.
441 ********************************************************************/
442 void svc_io_svc_status(char *desc,  SVC_STATUS *svc, prs_struct *ps, int depth)
443 {
444         if (svc == NULL) return;
445
446         prs_debug(ps, depth, desc, "svc_io_svc_status");
447         depth++;
448
449         prs_align(ps);
450
451         prs_uint32("svc_type", ps, depth, &(svc->svc_type));
452         prs_uint32("current_state", ps, depth, &(svc->current_state));
453         prs_uint32("controls_accepted", ps, depth, &(svc->controls_accepted));
454         prs_uint32("win32_exit_code", ps, depth, &(svc->win32_exit_code));
455         prs_uint32("svc_specific_exit_code", ps, depth, &(svc->svc_specific_exit_code));
456         prs_uint32("check_point", ps, depth, &(svc->check_point));
457         prs_uint32("wait_hint", ps, depth, &(svc->wait_hint));
458 }
459
460 /*******************************************************************
461 makes an SVC_Q_QUERY_SVC_CONFIG structure.
462 ********************************************************************/
463 void make_svc_q_query_svc_config(SVC_Q_QUERY_SVC_CONFIG *q_c, POLICY_HND *hnd,
464                                 uint32 buf_size)
465 {
466         if (q_c == NULL || hnd == NULL) return;
467
468         DEBUG(5,("make_svc_q_query_svc_config\n"));
469
470         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
471         q_c->buf_size = buf_size;
472 }
473
474 /*******************************************************************
475 reads or writes a structure.
476 ********************************************************************/
477 void svc_io_q_query_svc_config(char *desc,  SVC_Q_QUERY_SVC_CONFIG *q_u, prs_struct *ps, int depth)
478 {
479         if (q_u == NULL) return;
480
481         prs_debug(ps, depth, desc, "svc_io_q_query_svc_config");
482         depth++;
483
484         prs_align(ps);
485
486         smb_io_pol_hnd("", &(q_u->pol), ps, depth); 
487         prs_align(ps);
488         prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
489 }
490
491 /*******************************************************************
492 makes an SVC_R_QUERY_SVC_CONFIG structure.
493 ********************************************************************/
494 void make_svc_r_query_svc_config(SVC_R_QUERY_SVC_CONFIG *r_c, 
495                                 QUERY_SERVICE_CONFIG *cfg,
496                                 uint32 buf_size)
497 {
498         if (r_c == NULL) return;
499
500         DEBUG(5,("make_svc_r_query_svc_config\n"));
501
502         r_c->cfg      = cfg;
503         r_c->buf_size = buf_size;
504 }
505
506 /*******************************************************************
507 reads or writes a structure.
508 ********************************************************************/
509 void svc_io_r_query_svc_config(char *desc,  SVC_R_QUERY_SVC_CONFIG *r_u, prs_struct *ps, int depth)
510 {
511         if (r_u == NULL) return;
512
513         prs_debug(ps, depth, desc, "svc_io_r_query_svc_config");
514         depth++;
515
516         prs_align(ps);
517
518         svc_io_query_svc_cfg("cfg", r_u->cfg, ps, depth); 
519         prs_uint32("buf_size", ps, depth, &(r_u->buf_size));
520         prs_uint32("status  ", ps, depth, &(r_u->status  ));
521 }
522
523 /*******************************************************************
524 makes an SVC_Q_CLOSE structure.
525 ********************************************************************/
526 void make_svc_q_close(SVC_Q_CLOSE *q_c, POLICY_HND *hnd)
527 {
528         if (q_c == NULL || hnd == NULL) return;
529
530         DEBUG(5,("make_svc_q_close\n"));
531
532         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
533 }
534
535 /*******************************************************************
536 reads or writes a structure.
537 ********************************************************************/
538 void svc_io_q_close(char *desc,  SVC_Q_CLOSE *q_u, prs_struct *ps, int depth)
539 {
540         if (q_u == NULL) return;
541
542         prs_debug(ps, depth, desc, "svc_io_q_close");
543         depth++;
544
545         prs_align(ps);
546
547         smb_io_pol_hnd("", &(q_u->pol), ps, depth); 
548         prs_align(ps);
549 }
550
551 /*******************************************************************
552 reads or writes a structure.
553 ********************************************************************/
554 void svc_io_r_close(char *desc,  SVC_R_CLOSE *r_u, prs_struct *ps, int depth)
555 {
556         if (r_u == NULL) return;
557
558         prs_debug(ps, depth, desc, "svc_io_r_close");
559         depth++;
560
561         prs_align(ps);
562
563         smb_io_pol_hnd("", &(r_u->pol), ps, depth); 
564         prs_align(ps);
565
566         prs_uint32("status", ps, depth, &(r_u->status));
567 }
568