source3/rpc_parse/parse_eventlog.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1999,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1999,
   7  *  Copyright (C) Jean François Micouleau      1998-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 ********************************************************************/
  30 BOOL make_eventlog_q_open(EVENTLOG_Q_OPEN *q_u, char *journal, char *unk)
  31 {
  32         int len_journal = journal != NULL ? strlen(journal) : 0;
  33         int len_unk = unk != NULL ? strlen(unk) : 0;
  34
  35         q_u->ptr0=0x1;
  36         q_u->unk0=0x5c;
  37         q_u->unk1=0x01;
  38
  39         make_uni_hdr(&(q_u->hdr_source), len_journal);
  40         make_unistr2(&(q_u->uni_source), journal, len_journal);
  41
  42         make_uni_hdr(&(q_u->hdr_unk), len_unk);
  43         make_unistr2(&(q_u->uni_unk), unk, len_unk);
  44
  45         q_u->unk6=0x01;
  46         q_u->unk7=0x01;
  47
  48         return True;
  49 }
  50
  51 /*******************************************************************
  52 ********************************************************************/
  53 BOOL eventlog_io_q_open(char *desc, EVENTLOG_Q_OPEN *q_u, prs_struct *ps, int depth)
  54 {
  55         prs_debug(ps, depth, desc, "eventlog_io_q_open");
  56         depth++;
  57
  58         prs_align(ps);
  59
  60         prs_uint32("ptr0", ps, depth, &(q_u->ptr0));
  61
  62         prs_uint16("unk0", ps, depth, &(q_u->unk0));
  63         prs_uint16("unk1", ps, depth, &(q_u->unk1));
  64
  65         smb_io_unihdr("hdr_source", &(q_u->hdr_source), ps, depth);
  66         smb_io_unistr2("uni_source", &(q_u->uni_source),
  67                        q_u->hdr_source.buffer, ps, depth);
  68         prs_align(ps);
  69
  70         smb_io_unihdr("hdr_unk", &(q_u->hdr_unk), ps, depth);
  71         smb_io_unistr2("uni_unk", &(q_u->uni_unk),
  72                        q_u->hdr_unk.buffer, ps, depth);
  73         prs_align(ps);
  74
  75         prs_uint32("unk6", ps, depth, &(q_u->unk6));
  76         prs_uint32("unk7", ps, depth, &(q_u->unk7));
  77
  78         return True;
  79 }
  80
  81 /*******************************************************************
  82 ********************************************************************/
  83 BOOL eventlog_io_r_open(char *desc, EVENTLOG_R_OPEN *r_u, prs_struct *ps, int depth)
  84 {
  85         prs_debug(ps, depth, desc, "eventlog_io_r_open");
  86         depth++;
  87
  88         prs_align(ps);
  89         smb_io_pol_hnd("", &(r_u->pol), ps, depth);
  90         prs_uint32("status", ps, depth, &(r_u->status));
  91
  92         return True;
  93 }
  94
  95 /*******************************************************************
  96 ********************************************************************/
  97 BOOL make_eventlog_q_close(EVENTLOG_Q_CLOSE *q_u, POLICY_HND *pol)
  98 {
  99         memcpy(&(q_u->pol.data), pol->data, sizeof(q_u->pol.data));
 100
 101         return True;
 102 }
 103
 104 /*******************************************************************
 105 ********************************************************************/
 106 BOOL eventlog_io_q_close(char *desc, EVENTLOG_Q_CLOSE *q_u, prs_struct *ps, int depth)
 107 {
 108         prs_debug(ps, depth, desc, "eventlog_io_q_close");
 109         depth++;
 110
 111         prs_align(ps);
 112         smb_io_pol_hnd("", &(q_u->pol), ps, depth);
 113
 114         return True;
 115 }
 116
 117 /*******************************************************************
 118 ********************************************************************/
 119 BOOL eventlog_io_r_close(char *desc, EVENTLOG_R_CLOSE *r_u, prs_struct *ps, int depth)
 120 {
 121         prs_debug(ps, depth, desc, "eventlog_io_r_close");
 122         depth++;
 123
 124         prs_align(ps);
 125         smb_io_pol_hnd("", &(r_u->pol), ps, depth);
 126         prs_uint32("status", ps, depth, &(r_u->status));
 127
 128         return True;
 129 }
 130
 131 /*******************************************************************
 132 ********************************************************************/
 133 BOOL make_eventlog_q_numofeventlogrec(EVENTLOG_Q_NUMOFEVENTLOGREC *q_u, POLICY_HND *pol)
 134 {
 135         memcpy(&(q_u->pol.data), pol->data, sizeof(q_u->pol.data));
 136
 137
 138         return True;
 139 }
 140
 141 /*******************************************************************
 142 ********************************************************************/
 143 BOOL eventlog_io_q_numofeventlogrec(char *desc,EVENTLOG_Q_NUMOFEVENTLOGREC  *q_u, prs_struct *ps, int depth)
 144 {
 145         prs_debug(ps, depth, desc, "eventlog_io_q_numofeventlogrec");
 146         depth++;
 147
 148         prs_align(ps);
 149         smb_io_pol_hnd("", &(q_u->pol), ps, depth);
 150
 151
 152         return True;
 153 }
 154
 155 /*******************************************************************
 156 ********************************************************************/
 157 BOOL eventlog_io_r_numofeventlogrec(char *desc, EVENTLOG_R_NUMOFEVENTLOGREC *r_u, prs_struct *ps, int depth)
 158 {
 159         prs_debug(ps, depth, desc, "eventlog_io_r_numofeventlogrec");
 160         depth++;
 161
 162         prs_align(ps);
 163         prs_uint32("number", ps, depth, &(r_u->number));
 164         prs_uint32("status", ps, depth, &(r_u->status));
 165
 166         return True;
 167 }
 168
 169 /*******************************************************************
 170 ********************************************************************/
 171 BOOL make_eventlog_q_readeventlog(EVENTLOG_Q_READEVENTLOG *q_u, POLICY_HND *pol,
 172                                   uint32 flags, uint32 offset, uint32 number_of_bytes)
 173 {
 174         memcpy(&(q_u->pol.data), pol->data, sizeof(q_u->pol.data));
 175         q_u->flags=flags;
 176         q_u->offset=offset;
 177         q_u->number_of_bytes=number_of_bytes;
 178
 179         return True;
 180 }
 181
 182 /*******************************************************************
 183 ********************************************************************/
 184 BOOL eventlog_io_q_readeventlog(char *desc, EVENTLOG_Q_READEVENTLOG *q_u, prs_struct *ps, int depth)
 185 {
 186         prs_debug(ps, depth, desc, "eventlog_io_q_readeventlog");
 187         depth++;
 188
 189         prs_align(ps);
 190         smb_io_pol_hnd("", &(q_u->pol), ps, depth);
 191         prs_uint32("flags",           ps, depth, &(q_u->flags));
 192         prs_uint32("offset",          ps, depth, &(q_u->offset));
 193         prs_uint32("number_of_bytes", ps, depth, &(q_u->number_of_bytes));
 194
 195         return True;
 196 }
 197
 198 /*******************************************************************
 199 ********************************************************************/
 200 static BOOL eventlog_io_eventlog(char *desc, EVENTLOGRECORD *ev, prs_struct *ps, int depth)
 201 {
 202         prs_debug(ps, depth, desc, "eventlog_io_eventlog");
 203         depth++;
 204
 205         prs_align(ps);
 206         prs_uint32("size", ps, depth, &(ev->size));
 207         prs_uint32("reserved", ps, depth, &(ev->reserved));
 208         prs_uint32("recordnumber", ps, depth, &(ev->recordnumber));
 209         prs_uint32("creationtime", ps, depth, &(ev->creationtime));
 210         prs_uint32("writetime", ps, depth, &(ev->writetime));
 211         prs_uint32("eventnumber", ps, depth, &(ev->eventnumber));
 212
 213         prs_uint16("eventtype", ps, depth, &(ev->eventtype));
 214         prs_uint16("num_of_strings", ps, depth, &(ev->num_of_strings));
 215         prs_uint16("category", ps, depth, &(ev->category));
 216         prs_uint16("reserved_flag", ps, depth, &(ev->reserved_flag));
 217
 218         prs_uint32("closingrecord", ps, depth, &(ev->closingrecord));
 219         prs_uint32("stringoffset", ps, depth, &(ev->stringoffset));
 220         prs_uint32("sid_length", ps, depth, &(ev->sid_length));
 221         prs_uint32("sid_offset", ps, depth, &(ev->sid_offset));
 222         prs_uint32("data_length", ps, depth, &(ev->data_length));
 223         prs_uint32("data_offset", ps, depth, &(ev->data_offset));
 224
 225         smb_io_unistr("", &(ev->sourcename), ps, depth);
 226         smb_io_unistr("", &(ev->computername), ps, depth);
 227
 228         if (ev->sid_length!=0)
 229                 smb_io_unistr("", &(ev->sid), ps, depth);
 230
 231         if (ev->num_of_strings!=0)
 232                 smb_io_unistr("", &(ev->strings),ps, depth);
 233
 234         if (ev->data_length)
 235                 smb_io_unistr("", &(ev->data), ps, depth);
 236
 237         prs_uint32("size2", ps, depth, &(ev->size2));
 238
 239         return True;
 240 }
 241
 242 /*******************************************************************
 243 ********************************************************************/
 244 BOOL eventlog_io_r_readeventlog(char *desc, EVENTLOG_R_READEVENTLOG *r_u, prs_struct *ps, int depth)
 245 {
 246         prs_debug(ps, depth, desc, "eventlog_io_r_readeventlog");
 247         depth++;
 248
 249         prs_align(ps);
 250         prs_uint32("number_of_bytes", ps, depth, &(r_u->number_of_bytes));
 251
 252         if (r_u->number_of_bytes!= 0)
 253                 eventlog_io_eventlog("", r_u->event, ps, depth);
 254
 255         prs_uint32("sent_size", ps, depth, &(r_u->sent_size));
 256         prs_uint32("real_size", ps, depth, &(r_u->real_size));
 257         prs_uint32("status", ps, depth, &(r_u->status));
 258
 259         return True;
 260 }
 261