source/rpc_parse/parse_at.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 2.1.
   4  *  RPC parsing routines: scheduler service
   5  *  Copyright (C) Matthew Chapman                   1999,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1999,
   7  *  Copyright (C) Andrew Tridgell              1992-1999.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include "includes.h"
  25
  26 extern int DEBUGLEVEL;
  27
  28 /*******************************************************************
  29  make_at_q_add_job
  30  ********************************************************************/
  31 void make_at_q_add_job(AT_Q_ADD_JOB *q_a, char *server,
  32                         AT_JOB_INFO *info, char *command)
  33 {
  34         DEBUG(5,("make_at_q_add_job\n"));
  35
  36         make_buf_unistr2(&(q_a->uni_srv_name), &(q_a->ptr_srv_name), server);
  37         memcpy(&(q_a->info), info, sizeof(q_a->info));
  38         make_unistr2(&(q_a->command), command, strlen(command)+1);
  39 }
  40
  41 /*******************************************************************
  42 reads or writes a AT_JOB_INFO structure.
  43 ********************************************************************/
  44 void at_io_job_info(char *desc, AT_JOB_INFO *info, prs_struct *ps, int depth)
  45 {
  46         if (info == NULL) return;
  47
  48         prs_debug(ps, depth, desc, "at_io_job_info");
  49         depth++;
  50
  51         prs_align(ps);
  52
  53         prs_uint32("time", ps, depth, &(info->time));
  54         prs_uint32("monthdays", ps, depth, &(info->monthdays));
  55         prs_uint8("weekdays", ps, depth, &(info->weekdays));
  56         prs_uint8("flags", ps, depth, &(info->flags));
  57         prs_align(ps);
  58
  59         prs_uint32("ptr_command", ps, depth, &(info->ptr_command));
  60 }
  61
  62 /*******************************************************************
  63 reads or writes a AT_Q_ADD_JOB structure.
  64 ********************************************************************/
  65 void at_io_q_add_job(char *desc, AT_Q_ADD_JOB *q_a, prs_struct *ps, int depth)
  66 {
  67         if (q_a == NULL) return;
  68
  69         prs_debug(ps, depth, desc, "at_q_add_job");
  70         depth++;
  71
  72         prs_align(ps);
  73         prs_uint32("ptr_srv_name", ps, depth, &(q_a->ptr_srv_name));
  74         smb_io_unistr2("", &(q_a->uni_srv_name), q_a->ptr_srv_name, ps, depth);
  75         at_io_job_info("", &(q_a->info), ps, depth);
  76         smb_io_unistr2("", &(q_a->command), q_a->info.ptr_command, ps, depth);
  77 }
  78
  79 /*******************************************************************
  80 reads or writes a AT_R_ADD_JOB structure.
  81 ********************************************************************/
  82 void at_io_r_add_job(char *desc, AT_R_ADD_JOB *r_a, prs_struct *ps, int depth)
  83 {
  84         if (r_a == NULL) return;
  85
  86         prs_debug(ps, depth, desc, "at_r_add_job");
  87         depth++;
  88
  89         prs_align(ps);
  90         prs_uint32("jobid", ps, depth, &(r_a->jobid));
  91         prs_uint32("status", ps, depth, &(r_a->status));
  92 }
  93
  94 /*******************************************************************
  95  make_at_q_del_job
  96  ********************************************************************/
  97 void make_at_q_del_job(AT_Q_DEL_JOB *q_a, char *server, uint32 min_jobid,
  98                        uint32 max_jobid)
  99 {
 100         DEBUG(5,("make_at_q_del_job\n"));
 101
 102         make_buf_unistr2(&(q_a->uni_srv_name), &(q_a->ptr_srv_name), server);
 103         q_a->min_jobid = min_jobid;
 104         q_a->max_jobid = max_jobid;
 105 }
 106
 107 /*******************************************************************
 108 reads or writes a AT_Q_DEL_JOB structure.
 109 ********************************************************************/
 110 void at_io_q_del_job(char *desc, AT_Q_DEL_JOB *q_d, prs_struct *ps, int depth)
 111 {
 112         if (q_d == NULL) return;
 113
 114         prs_debug(ps, depth, desc, "at_q_del_job");
 115         depth++;
 116
 117         prs_align(ps);
 118
 119         prs_uint32("ptr_srv_name", ps, depth, &(q_d->ptr_srv_name));
 120         smb_io_unistr2("", &(q_d->uni_srv_name), q_d->ptr_srv_name, ps, depth);
 121         prs_align(ps);
 122         prs_uint32("min_jobid", ps, depth, &(q_d->min_jobid));
 123         prs_uint32("max_jobid", ps, depth, &(q_d->max_jobid));
 124 }
 125
 126 /*******************************************************************
 127 reads or writes a AT_R_DEL_JOB structure.
 128 ********************************************************************/
 129 void at_io_r_del_job(char *desc, AT_R_DEL_JOB *r_d, prs_struct *ps, int depth)
 130 {
 131         if (r_d == NULL) return;
 132
 133         prs_debug(ps, depth, desc, "at_r_del_job");
 134         depth++;
 135
 136         prs_align(ps);
 137         prs_uint32("status", ps, depth, &(r_d->status));
 138 }
 139
 140 /*******************************************************************
 141  make_at_q_enum_jobs
 142  ********************************************************************/
 143 void make_at_q_enum_jobs(AT_Q_ENUM_JOBS *q_e, char *server)
 144 {
 145         DEBUG(5,("make_at_q_enum_jobs\n"));
 146
 147         make_buf_unistr2(&(q_e->uni_srv_name), &(q_e->ptr_srv_name), server);
 148         q_e->unknown0 = 0;
 149         q_e->unknown1 = 0;
 150         q_e->max_len = 0xffff;
 151         q_e->ptr_resume = 1;
 152         q_e->hnd_resume = 0;
 153 }
 154
 155 /*******************************************************************
 156 reads or writes a AT_Q_ENUM_JOBS structure.
 157 ********************************************************************/
 158 void at_io_q_enum_jobs(char *desc, AT_Q_ENUM_JOBS *q_e, prs_struct *ps, int depth)
 159 {
 160         if (q_e == NULL) return;
 161
 162         prs_debug(ps, depth, desc, "at_q_enum_jobs");
 163         depth++;
 164
 165         prs_align(ps);
 166         prs_uint32("ptr_srv_name", ps, depth, &(q_e->ptr_srv_name));
 167         smb_io_unistr2("", &(q_e->uni_srv_name), q_e->ptr_srv_name, ps, depth);
 168         prs_align(ps);
 169         prs_uint32("unknown0", ps, depth, &(q_e->unknown0));
 170         prs_uint32("unknown1", ps, depth, &(q_e->unknown1));
 171         prs_uint32("max_len" , ps, depth, &(q_e->max_len ));
 172
 173         prs_uint32("ptr_resume", ps, depth, &(q_e->ptr_resume));
 174         prs_uint32("hnd_resume", ps, depth, &(q_e->hnd_resume));
 175 }
 176
 177 /*******************************************************************
 178 reads or writes a AT_R_ENUM_JOBS structure.
 179 ********************************************************************/
 180 void at_io_r_enum_jobs(char *desc, AT_R_ENUM_JOBS *r_e, prs_struct *ps, int depth)
 181 {
 182         if (r_e == NULL) return;
 183
 184         prs_debug(ps, depth, desc, "at_r_enum_jobs");
 185         depth++;
 186
 187         prs_align(ps);
 188         prs_uint32("num_entries", ps, depth, &(r_e->num_entries));
 189         prs_uint32("ptr_entries", ps, depth, &(r_e->ptr_entries));
 190
 191         if (r_e->ptr_entries != 0)
 192         {
 193                 int i;
 194
 195                 prs_uint32("num_entries2", ps, depth, &(r_e->num_entries2));
 196                 if (r_e->num_entries2 != r_e->num_entries)
 197                 {
 198                         /* RPC fault */
 199                         return;
 200                 }
 201
 202                 SMB_ASSERT_ARRAY(r_e->info, r_e->num_entries2);
 203
 204                 for (i = 0; i < r_e->num_entries2; i++)
 205                 {
 206                         prs_grow(ps);
 207                         prs_uint32("jobid", ps, depth, &(r_e->info[i].jobid));
 208                         at_io_job_info("", &(r_e->info[i].info), ps, depth);
 209                 }
 210
 211                 for (i = 0; i < r_e->num_entries2; i++)
 212                 {
 213                         prs_grow(ps);
 214                         smb_io_unistr2("", &(r_e->command[i]),
 215                                  r_e->info[i].info.ptr_command, ps, depth);
 216                 }
 217         }
 218
 219         prs_align(ps);
 220         prs_uint32("total_entries", ps, depth, &(r_e->total_entries));
 221         prs_uint32("ptr_resume"   , ps, depth, &(r_e->ptr_resume   ));
 222         prs_uint32("hnd_resume"   , ps, depth, &(r_e->hnd_resume   ));
 223
 224         prs_uint32("status", ps, depth, &(r_e->status));
 225 }
 226
 227 /*******************************************************************
 228  make_at_q_query_job
 229  ********************************************************************/
 230 void make_at_q_query_job(AT_Q_QUERY_JOB *q_q, char *server, uint32 jobid)
 231 {
 232         DEBUG(5,("make_at_q_query_job\n"));
 233
 234         make_buf_unistr2(&(q_q->uni_srv_name), &(q_q->ptr_srv_name), server);
 235         q_q->jobid = jobid;
 236 }
 237
 238 /*******************************************************************
 239 reads or writes a AT_Q_QUERY_JOB structure.
 240 ********************************************************************/
 241 void at_io_q_query_job(char *desc, AT_Q_QUERY_JOB *q_q, prs_struct *ps, int depth)
 242 {
 243         if (q_q == NULL) return;
 244
 245         prs_debug(ps, depth, desc, "at_q_query_job");
 246         depth++;
 247
 248         prs_align(ps);
 249         prs_uint32("ptr_srv_name", ps, depth, &(q_q->ptr_srv_name));
 250         smb_io_unistr2("", &(q_q->uni_srv_name), q_q->ptr_srv_name, ps, depth);
 251         prs_align(ps);
 252         prs_uint32("jobid", ps, depth, &(q_q->jobid));
 253 }
 254
 255 /*******************************************************************
 256 reads or writes a AT_R_QUERY_JOB structure.
 257 ********************************************************************/
 258 void at_io_r_query_job(char *desc, AT_R_QUERY_JOB *r_q, prs_struct *ps, int depth)
 259 {
 260         if (r_q == NULL) return;
 261
 262         prs_debug(ps, depth, desc, "at_r_query_job");
 263         depth++;
 264
 265         prs_align(ps);
 266         prs_uint32("ptr_info", ps, depth, &(r_q->ptr_info));
 267         if (r_q->ptr_info != 0)
 268         {
 269                 at_io_job_info("", &(r_q->info), ps, depth);
 270                 smb_io_unistr2("", &(r_q->command), r_q->info.ptr_command, ps, depth);
 271         }
 272
 273         prs_align(ps);
 274         prs_uint32("status", ps, depth, &(r_q->status));
 275 }