← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to source/rpc_parse/parse_shutdown.c

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/rpc_parse/parse_shutdown.c
1
 
/*
2
 
 *  Unix SMB/CIFS implementation.
3
 
 *  RPC Pipe client / server routines
4
 
 *  Copyright (C) Jim McDonough (jmcd@us.ibm.com)   2003.
5
 
 *  Copyright (C) Gerald (Jerry) Carter             2002-2005.
6
 
 *  
7
 
 *  This program is free software; you can redistribute it and/or modify
8
 
 *  it under the terms of the GNU General Public License as published by
9
 
 *  the Free Software Foundation; either version 2 of the License, or
10
 
 *  (at your option) any later version.
11
 
 *  
12
 
 *  This program is distributed in the hope that it will be useful,
13
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 *  GNU General Public License for more details.
16
 
 *  
17
 
 *  You should have received a copy of the GNU General Public License
18
 
 *  along with this program; if not, write to the Free Software
19
 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
 
 */
21
 
 
22
 
#include "includes.h"
23
 
 
24
 
#undef DBGC_CLASS
25
 
#define DBGC_CLASS DBGC_RPC_PARSE
26
 
 
27
 
/*******************************************************************
28
 
Inits a structure.
29
 
********************************************************************/
30
 
 
31
 
void init_shutdown_q_init(SHUTDOWN_Q_INIT *q_s, const char *msg,
32
 
                        uint32 timeout, BOOL do_reboot, BOOL force)
33
 
{
34
 
        q_s->server = TALLOC_P( get_talloc_ctx(), uint16 );
35
 
        if (!q_s->server) {
36
 
                smb_panic("init_shutdown_q_init: talloc fail.\n");
37
 
                return;
38
 
        }
39
 
 
40
 
        *q_s->server = 0x1;
41
 
 
42
 
        q_s->message = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
43
 
        if (!q_s->message) {
44
 
                smb_panic("init_shutdown_q_init: talloc fail.\n");
45
 
                return;
46
 
        }
47
 
 
48
 
        if ( msg && *msg ) {
49
 
                init_unistr4( q_s->message, msg, UNI_FLAGS_NONE );
50
 
 
51
 
                /* Win2000 is apparently very sensitive to these lengths */
52
 
                /* do a special case here */
53
 
 
54
 
                q_s->message->string->uni_max_len++;
55
 
                q_s->message->size += 2;
56
 
        }
57
 
 
58
 
        q_s->timeout = timeout;
59
 
 
60
 
        q_s->reboot = do_reboot ? 1 : 0;
61
 
        q_s->force = force ? 1 : 0;
62
 
}
63
 
 
64
 
/*******************************************************************
65
 
********************************************************************/
66
 
 
67
 
void init_shutdown_q_init_ex(SHUTDOWN_Q_INIT_EX * q_u_ex, const char *msg,
68
 
                        uint32 timeout, BOOL do_reboot, BOOL force, uint32 reason)
69
 
{
70
 
        SHUTDOWN_Q_INIT q_u;
71
 
        
72
 
        ZERO_STRUCT( q_u );
73
 
        
74
 
        init_shutdown_q_init( &q_u, msg, timeout, do_reboot, force );
75
 
        
76
 
        /* steal memory */
77
 
        
78
 
        q_u_ex->server  = q_u.server;
79
 
        q_u_ex->message = q_u.message;
80
 
        
81
 
        q_u_ex->reboot  = q_u.reboot;
82
 
        q_u_ex->force   = q_u.force;
83
 
        
84
 
        q_u_ex->reason = reason;
85
 
}
86
 
 
87
 
/*******************************************************************
88
 
reads or writes a structure.
89
 
********************************************************************/
90
 
 
91
 
BOOL shutdown_io_q_init(const char *desc, SHUTDOWN_Q_INIT *q_s, prs_struct *ps,
92
 
                        int depth)
93
 
{
94
 
        if (q_s == NULL)
95
 
                return False;
96
 
 
97
 
        prs_debug(ps, depth, desc, "shutdown_io_q_init");
98
 
        depth++;
99
 
 
100
 
        if (!prs_align(ps))
101
 
                return False;
102
 
 
103
 
        if (!prs_pointer("server", ps, depth, (void*)&q_s->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
104
 
                return False;
105
 
        if (!prs_align(ps))
106
 
                return False;
107
 
 
108
 
        if (!prs_pointer("message", ps, depth, (void*)&q_s->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
109
 
                return False;
110
 
 
111
 
        if (!prs_align(ps))
112
 
                return False;
113
 
 
114
 
        if (!prs_uint32("timeout", ps, depth, &(q_s->timeout)))
115
 
                return False;
116
 
 
117
 
        if (!prs_uint8("force  ", ps, depth, &(q_s->force)))
118
 
                return False;
119
 
        if (!prs_uint8("reboot ", ps, depth, &(q_s->reboot)))
120
 
                return False;
121
 
 
122
 
        return True;
123
 
}
124
 
 
125
 
/*******************************************************************
126
 
reads or writes a structure.
127
 
********************************************************************/
128
 
BOOL shutdown_io_r_init(const char *desc, SHUTDOWN_R_INIT* r_s, prs_struct *ps,
129
 
                        int depth)
130
 
{
131
 
        if (r_s == NULL)
132
 
                return False;
133
 
 
134
 
        prs_debug(ps, depth, desc, "shutdown_io_r_init");
135
 
        depth++;
136
 
 
137
 
        if(!prs_align(ps))
138
 
                return False;
139
 
 
140
 
        if(!prs_werror("status", ps, depth, &r_s->status))
141
 
                return False;
142
 
 
143
 
        return True;
144
 
}
145
 
 
146
 
/*******************************************************************
147
 
reads or writes a REG_Q_SHUTDOWN_EX structure.
148
 
********************************************************************/
149
 
 
150
 
BOOL shutdown_io_q_init_ex(const char *desc, SHUTDOWN_Q_INIT_EX * q_s, prs_struct *ps,
151
 
                       int depth)
152
 
{
153
 
        if (q_s == NULL)
154
 
                return False;
155
 
 
156
 
        prs_debug(ps, depth, desc, "shutdown_io_q_init_ex");
157
 
        depth++;
158
 
 
159
 
        if (!prs_align(ps))
160
 
                return False;
161
 
 
162
 
        if (!prs_pointer("server", ps, depth, (void*)&q_s->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
163
 
                return False;
164
 
        if (!prs_align(ps))
165
 
                return False;
166
 
 
167
 
        if (!prs_pointer("message", ps, depth, (void*)&q_s->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
168
 
                return False;
169
 
 
170
 
        if (!prs_align(ps))
171
 
                return False;
172
 
 
173
 
        if (!prs_uint32("timeout", ps, depth, &(q_s->timeout)))
174
 
                return False;
175
 
 
176
 
        if (!prs_uint8("force  ", ps, depth, &(q_s->force)))
177
 
                return False;
178
 
        if (!prs_uint8("reboot ", ps, depth, &(q_s->reboot)))
179
 
                return False;
180
 
 
181
 
        if (!prs_align(ps))
182
 
                return False;
183
 
        if (!prs_uint32("reason", ps, depth, &(q_s->reason)))
184
 
                return False;
185
 
 
186
 
 
187
 
        return True;
188
 
}
189
 
 
190
 
/*******************************************************************
191
 
reads or writes a REG_R_SHUTDOWN_EX structure.
192
 
********************************************************************/
193
 
BOOL shutdown_io_r_init_ex(const char *desc, SHUTDOWN_R_INIT_EX * r_s, prs_struct *ps,
194
 
                       int depth)
195
 
{
196
 
        if (r_s == NULL)
197
 
                return False;
198
 
 
199
 
        prs_debug(ps, depth, desc, "shutdown_io_r_init_ex");
200
 
        depth++;
201
 
 
202
 
        if(!prs_align(ps))
203
 
                return False;
204
 
 
205
 
        if(!prs_werror("status", ps, depth, &r_s->status))
206
 
                return False;
207
 
 
208
 
        return True;
209
 
}
210
 
 
211
 
 
212
 
/*******************************************************************
213
 
Inits a structure.
214
 
********************************************************************/
215
 
void init_shutdown_q_abort(SHUTDOWN_Q_ABORT *q_s)
216
 
{
217
 
        q_s->server = TALLOC_P( get_talloc_ctx(), uint16 );
218
 
        if (!q_s->server) {
219
 
                smb_panic("init_shutdown_q_abort: talloc fail.\n");
220
 
                return;
221
 
        }
222
 
                
223
 
        *q_s->server = 0x1;
224
 
}
225
 
 
226
 
/*******************************************************************
227
 
reads or writes a structure.
228
 
********************************************************************/
229
 
BOOL shutdown_io_q_abort(const char *desc, SHUTDOWN_Q_ABORT *q_s,
230
 
                         prs_struct *ps, int depth)
231
 
{
232
 
        if (q_s == NULL)
233
 
                return False;
234
 
 
235
 
        prs_debug(ps, depth, desc, "shutdown_io_q_abort");
236
 
        depth++;
237
 
 
238
 
        if (!prs_align(ps))
239
 
                return False;
240
 
 
241
 
        if (!prs_pointer("server", ps, depth, (void*)&q_s->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
242
 
                return False;
243
 
        if (!prs_align(ps))
244
 
                return False;
245
 
 
246
 
        return True;
247
 
}
248
 
 
249
 
/*******************************************************************
250
 
reads or writes a structure.
251
 
********************************************************************/
252
 
BOOL shutdown_io_r_abort(const char *desc, SHUTDOWN_R_ABORT *r_s,
253
 
                         prs_struct *ps, int depth)
254
 
{
255
 
        if (r_s == NULL)
256
 
                return False;
257
 
 
258
 
        prs_debug(ps, depth, desc, "shutdown_io_r_abort");
259
 
        depth++;
260
 
 
261
 
        if (!prs_align(ps))
262
 
                return False;
263
 
 
264
 
        if (!prs_werror("status", ps, depth, &r_s->status))
265
 
                return False;
266
 
 
267
 
        return True;
268
 
}