← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/samba/oneiric-security

« back to all changes in this revision

Viewing changes to .pc/fix-windows7-print-connection.patch/librpc/gen_ndr/eventlog.h

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-03-10 10:03:01 UTC
  • mfrom: (0.39.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110310100301-jfjg41wv0iq05zj4
Tags: 2:3.5.8~dfsg-1ubuntu1
https://launchpad.net/bugs/639768
* Merge from debian unstable.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access. 
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksmbpasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
    - Add cuups breaks to push the package to aslo upgrade cups (LP: #639768)
  + debian/rules:
    - enable "native" PIE hardening.
    - Add BIND_NOW to maximize benefit of RELRO hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
    - Don't ship the /etc/network/if-up.d file.
  + debian/samba.postinst: 
    - Fixed bashism.
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/samba.logrotate: Make it upstart compatible
  + debian/samba-common.dhcp: Fix typo to get a proper parsing in
    /etc/samba/dhcp.
  + Dropped:
    - debian/patches/fix-windows7-print-connection.patch: Merged upstream.
    - debian/patches/security-CVE-2011-0719.patch: Merged upstream. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/fix-windows7-print-connection.patch/librpc/gen_ndr/eventlog.h
1
 
/* header auto-generated by pidl */
2
 
 
3
 
#include <stdint.h>
4
 
 
5
 
#include "libcli/util/ntstatus.h"
6
 
 
7
 
#include "librpc/gen_ndr/lsa.h"
8
 
#include "librpc/gen_ndr/security.h"
9
 
#ifndef _HEADER_eventlog
10
 
#define _HEADER_eventlog
11
 
 
12
 
/* bitmap eventlogReadFlags */
13
 
#define EVENTLOG_SEQUENTIAL_READ ( 0x0001 )
14
 
#define EVENTLOG_SEEK_READ ( 0x0002 )
15
 
#define EVENTLOG_FORWARDS_READ ( 0x0004 )
16
 
#define EVENTLOG_BACKWARDS_READ ( 0x0008 )
17
 
 
18
 
enum eventlogEventTypes
19
 
#ifndef USE_UINT_ENUMS
20
 
 {
21
 
        EVENTLOG_SUCCESS=(int)(0x0000),
22
 
        EVENTLOG_ERROR_TYPE=(int)(0x0001),
23
 
        EVENTLOG_WARNING_TYPE=(int)(0x0002),
24
 
        EVENTLOG_INFORMATION_TYPE=(int)(0x0004),
25
 
        EVENTLOG_AUDIT_SUCCESS=(int)(0x0008),
26
 
        EVENTLOG_AUDIT_FAILURE=(int)(0x0010)
27
 
}
28
 
#else
29
 
 { __donnot_use_enum_eventlogEventTypes=0x7FFFFFFF}
30
 
#define EVENTLOG_SUCCESS ( 0x0000 )
31
 
#define EVENTLOG_ERROR_TYPE ( 0x0001 )
32
 
#define EVENTLOG_WARNING_TYPE ( 0x0002 )
33
 
#define EVENTLOG_INFORMATION_TYPE ( 0x0004 )
34
 
#define EVENTLOG_AUDIT_SUCCESS ( 0x0008 )
35
 
#define EVENTLOG_AUDIT_FAILURE ( 0x0010 )
36
 
#endif
37
 
;
38
 
 
39
 
struct eventlog_OpenUnknown0 {
40
 
        uint16_t unknown0;
41
 
        uint16_t unknown1;
42
 
};
43
 
 
44
 
struct eventlog_Record_tdb {
45
 
        uint32_t size;
46
 
        const char *reserved;/* [value("eLfL"),charset(DOS)] */
47
 
        uint32_t record_number;
48
 
        time_t time_generated;
49
 
        time_t time_written;
50
 
        uint32_t event_id;
51
 
        enum eventlogEventTypes event_type;
52
 
        uint16_t num_of_strings;/* [range(0,256)] */
53
 
        uint16_t event_category;
54
 
        uint16_t reserved_flags;
55
 
        uint32_t closing_record_number;
56
 
        uint32_t stringoffset;
57
 
        uint32_t sid_length;/* [value(sid.length)] */
58
 
        uint32_t sid_offset;
59
 
        uint32_t data_length;/* [value(data.length)] */
60
 
        uint32_t data_offset;
61
 
        uint32_t source_name_len;/* [value(2*strlen_m_term(source_name))] */
62
 
        const char * source_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
63
 
        uint32_t computer_name_len;/* [value(2*strlen_m_term(computer_name))] */
64
 
        const char * computer_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
65
 
        uint32_t sid_padding;
66
 
        DATA_BLOB sid;
67
 
        uint32_t strings_len;/* [value(2*ndr_size_string_array(strings,num_of_strings,LIBNDR_FLAG_STR_NULLTERM))] */
68
 
        const char * *strings;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
69
 
        DATA_BLOB data;
70
 
        uint32_t padding;
71
 
}/* [public,flag(LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX)] */;
72
 
 
73
 
enum EVENTLOG_HEADER_FLAGS
74
 
#ifndef USE_UINT_ENUMS
75
 
 {
76
 
        ELF_LOGFILE_HEADER_DIRTY=(int)(0x0001),
77
 
        ELF_LOGFILE_HEADER_WRAP=(int)(0x0002),
78
 
        ELF_LOGFILE_LOGFULL_WRITTEN=(int)(0x0004),
79
 
        ELF_LOGFILE_ARCHIVE_SET=(int)(0x0008)
80
 
}
81
 
#else
82
 
 { __donnot_use_enum_EVENTLOG_HEADER_FLAGS=0x7FFFFFFF}
83
 
#define ELF_LOGFILE_HEADER_DIRTY ( 0x0001 )
84
 
#define ELF_LOGFILE_HEADER_WRAP ( 0x0002 )
85
 
#define ELF_LOGFILE_LOGFULL_WRITTEN ( 0x0004 )
86
 
#define ELF_LOGFILE_ARCHIVE_SET ( 0x0008 )
87
 
#endif
88
 
;
89
 
 
90
 
struct EVENTLOGHEADER {
91
 
        uint32_t HeaderSize;/* [value(0x30)] */
92
 
        const char *Signature;/* [value("LfLe"),charset(DOS)] */
93
 
        uint32_t MajorVersion;/* [value] */
94
 
        uint32_t MinorVersion;/* [value] */
95
 
        uint32_t StartOffset;
96
 
        uint32_t EndOffset;
97
 
        uint32_t CurrentRecordNumber;
98
 
        uint32_t OldestRecordNumber;
99
 
        uint32_t MaxSize;
100
 
        enum EVENTLOG_HEADER_FLAGS Flags;
101
 
        uint32_t Retention;
102
 
        uint32_t EndHeaderSize;/* [value(0x30)] */
103
 
}/* [public] */;
104
 
 
105
 
struct EVENTLOGRECORD {
106
 
        uint32_t Length;
107
 
        const char *Reserved;/* [value("LfLe"),charset(DOS)] */
108
 
        uint32_t RecordNumber;
109
 
        time_t TimeGenerated;
110
 
        time_t TimeWritten;
111
 
        uint32_t EventID;
112
 
        enum eventlogEventTypes EventType;
113
 
        uint16_t NumStrings;
114
 
        uint16_t EventCategory;
115
 
        uint16_t ReservedFlags;
116
 
        uint32_t ClosingRecordNumber;
117
 
        uint32_t StringOffset;/* [value(56+2*(strlen_m_term(SourceName)+strlen_m_term(Computername))+UserSidLength)] */
118
 
        uint32_t UserSidLength;/* [value(ndr_size_dom_sid0(&UserSid,ndr->flags))] */
119
 
        uint32_t UserSidOffset;/* [value(56+2*(strlen_m_term(SourceName)+strlen_m_term(Computername)))] */
120
 
        uint32_t DataLength;
121
 
        uint32_t DataOffset;/* [value(56+2*(strlen_m_term(SourceName)+strlen_m_term(Computername))+UserSidLength+(2*ndr_size_string_array(Strings,NumStrings,LIBNDR_FLAG_STR_NULLTERM)))] */
122
 
        const char * SourceName;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
123
 
        const char * Computername;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
124
 
        struct dom_sid0 UserSid;/* [subcontext_size(UserSidLength),subcontext(0),flag(LIBNDR_FLAG_ALIGN4)] */
125
 
        const char * *Strings;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
126
 
        uint8_t *Data;/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */
127
 
        const char * Pad;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
128
 
        uint32_t Length2;/* [value(Length)] */
129
 
}/* [gensize,public] */;
130
 
 
131
 
struct EVENTLOGEOF {
132
 
        uint32_t RecordSizeBeginning;/* [value(0x28)] */
133
 
        uint32_t One;/* [value(0x11111111)] */
134
 
        uint32_t Two;/* [value(0x22222222)] */
135
 
        uint32_t Three;/* [value(0x33333333)] */
136
 
        uint32_t Four;/* [value(0x44444444)] */
137
 
        uint32_t BeginRecord;
138
 
        uint32_t EndRecord;
139
 
        uint32_t CurrentRecordNumber;
140
 
        uint32_t OldestRecordNumber;
141
 
        uint32_t RecordSizeEnd;/* [value(0x28)] */
142
 
}/* [public] */;
143
 
 
144
 
struct EVENTLOG_EVT_FILE {
145
 
        struct EVENTLOGHEADER hdr;
146
 
        struct EVENTLOGRECORD *records;
147
 
        struct EVENTLOGEOF eof;
148
 
}/* [public] */;
149
 
 
150
 
struct EVENTLOG_FULL_INFORMATION {
151
 
        uint32_t full;
152
 
}/* [public] */;
153
 
 
154
 
 
155
 
struct eventlog_ClearEventLogW {
156
 
        struct {
157
 
                struct policy_handle *handle;/* [ref] */
158
 
                struct lsa_String *backupfile;/* [unique] */
159
 
        } in;
160
 
 
161
 
        struct {
162
 
                NTSTATUS result;
163
 
        } out;
164
 
 
165
 
};
166
 
 
167
 
 
168
 
struct eventlog_BackupEventLogW {
169
 
        struct {
170
 
                struct policy_handle *handle;/* [ref] */
171
 
                struct lsa_String *backup_filename;/* [ref] */
172
 
        } in;
173
 
 
174
 
        struct {
175
 
                NTSTATUS result;
176
 
        } out;
177
 
 
178
 
};
179
 
 
180
 
 
181
 
struct eventlog_CloseEventLog {
182
 
        struct {
183
 
                struct policy_handle *handle;/* [ref] */
184
 
        } in;
185
 
 
186
 
        struct {
187
 
                struct policy_handle *handle;/* [ref] */
188
 
                NTSTATUS result;
189
 
        } out;
190
 
 
191
 
};
192
 
 
193
 
 
194
 
struct eventlog_DeregisterEventSource {
195
 
        struct {
196
 
                struct policy_handle *handle;/* [ref] */
197
 
        } in;
198
 
 
199
 
        struct {
200
 
                struct policy_handle *handle;/* [ref] */
201
 
                NTSTATUS result;
202
 
        } out;
203
 
 
204
 
};
205
 
 
206
 
 
207
 
struct eventlog_GetNumRecords {
208
 
        struct {
209
 
                struct policy_handle *handle;/* [ref] */
210
 
        } in;
211
 
 
212
 
        struct {
213
 
                uint32_t *number;/* [ref] */
214
 
                NTSTATUS result;
215
 
        } out;
216
 
 
217
 
};
218
 
 
219
 
 
220
 
struct eventlog_GetOldestRecord {
221
 
        struct {
222
 
                struct policy_handle *handle;/* [ref] */
223
 
        } in;
224
 
 
225
 
        struct {
226
 
                uint32_t *oldest_entry;/* [ref] */
227
 
                NTSTATUS result;
228
 
        } out;
229
 
 
230
 
};
231
 
 
232
 
 
233
 
struct eventlog_ChangeNotify {
234
 
        struct {
235
 
                NTSTATUS result;
236
 
        } out;
237
 
 
238
 
};
239
 
 
240
 
 
241
 
struct eventlog_OpenEventLogW {
242
 
        struct {
243
 
                struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
244
 
                struct lsa_String *logname;/* [ref] */
245
 
                struct lsa_String *servername;/* [ref] */
246
 
                uint32_t major_version;
247
 
                uint32_t minor_version;
248
 
        } in;
249
 
 
250
 
        struct {
251
 
                struct policy_handle *handle;/* [ref] */
252
 
                NTSTATUS result;
253
 
        } out;
254
 
 
255
 
};
256
 
 
257
 
 
258
 
struct eventlog_RegisterEventSourceW {
259
 
        struct {
260
 
                struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
261
 
                struct lsa_String *module_name;/* [ref] */
262
 
                struct lsa_String *reg_module_name;/* [ref] */
263
 
                uint32_t major_version;
264
 
                uint32_t minor_version;
265
 
        } in;
266
 
 
267
 
        struct {
268
 
                struct policy_handle *log_handle;/* [ref] */
269
 
                NTSTATUS result;
270
 
        } out;
271
 
 
272
 
};
273
 
 
274
 
 
275
 
struct eventlog_OpenBackupEventLogW {
276
 
        struct {
277
 
                struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
278
 
                struct lsa_String *backup_logname;/* [ref] */
279
 
                uint32_t major_version;
280
 
                uint32_t minor_version;
281
 
        } in;
282
 
 
283
 
        struct {
284
 
                struct policy_handle *handle;/* [ref] */
285
 
                NTSTATUS result;
286
 
        } out;
287
 
 
288
 
};
289
 
 
290
 
 
291
 
struct eventlog_ReadEventLogW {
292
 
        struct {
293
 
                struct policy_handle *handle;/* [ref] */
294
 
                uint32_t flags;
295
 
                uint32_t offset;
296
 
                uint32_t number_of_bytes;/* [range(0,0x7FFFF)] */
297
 
        } in;
298
 
 
299
 
        struct {
300
 
                uint8_t *data;/* [ref,size_is(number_of_bytes)] */
301
 
                uint32_t *sent_size;/* [ref] */
302
 
                uint32_t *real_size;/* [ref] */
303
 
                NTSTATUS result;
304
 
        } out;
305
 
 
306
 
};
307
 
 
308
 
 
309
 
struct eventlog_ReportEventW {
310
 
        struct {
311
 
                struct policy_handle *handle;/* [ref] */
312
 
                time_t timestamp;
313
 
                enum eventlogEventTypes event_type;
314
 
                uint16_t event_category;
315
 
                uint32_t event_id;
316
 
                uint16_t num_of_strings;/* [range(0,256)] */
317
 
                uint32_t data_size;/* [range(0,0x3FFFF)] */
318
 
                struct lsa_String *servername;/* [ref] */
319
 
                struct dom_sid *user_sid;/* [unique] */
320
 
                struct lsa_String **strings;/* [unique,size_is(num_of_strings)] */
321
 
                uint8_t *data;/* [unique,size_is(data_size)] */
322
 
                uint16_t flags;
323
 
                uint32_t *record_number;/* [unique] */
324
 
                time_t *time_written;/* [unique] */
325
 
        } in;
326
 
 
327
 
        struct {
328
 
                uint32_t *record_number;/* [unique] */
329
 
                time_t *time_written;/* [unique] */
330
 
                NTSTATUS result;
331
 
        } out;
332
 
 
333
 
};
334
 
 
335
 
 
336
 
struct eventlog_ClearEventLogA {
337
 
        struct {
338
 
                NTSTATUS result;
339
 
        } out;
340
 
 
341
 
};
342
 
 
343
 
 
344
 
struct eventlog_BackupEventLogA {
345
 
        struct {
346
 
                NTSTATUS result;
347
 
        } out;
348
 
 
349
 
};
350
 
 
351
 
 
352
 
struct eventlog_OpenEventLogA {
353
 
        struct {
354
 
                NTSTATUS result;
355
 
        } out;
356
 
 
357
 
};
358
 
 
359
 
 
360
 
struct eventlog_RegisterEventSourceA {
361
 
        struct {
362
 
                NTSTATUS result;
363
 
        } out;
364
 
 
365
 
};
366
 
 
367
 
 
368
 
struct eventlog_OpenBackupEventLogA {
369
 
        struct {
370
 
                NTSTATUS result;
371
 
        } out;
372
 
 
373
 
};
374
 
 
375
 
 
376
 
struct eventlog_ReadEventLogA {
377
 
        struct {
378
 
                NTSTATUS result;
379
 
        } out;
380
 
 
381
 
};
382
 
 
383
 
 
384
 
struct eventlog_ReportEventA {
385
 
        struct {
386
 
                NTSTATUS result;
387
 
        } out;
388
 
 
389
 
};
390
 
 
391
 
 
392
 
struct eventlog_RegisterClusterSvc {
393
 
        struct {
394
 
                NTSTATUS result;
395
 
        } out;
396
 
 
397
 
};
398
 
 
399
 
 
400
 
struct eventlog_DeregisterClusterSvc {
401
 
        struct {
402
 
                NTSTATUS result;
403
 
        } out;
404
 
 
405
 
};
406
 
 
407
 
 
408
 
struct eventlog_WriteClusterEvents {
409
 
        struct {
410
 
                NTSTATUS result;
411
 
        } out;
412
 
 
413
 
};
414
 
 
415
 
 
416
 
struct eventlog_GetLogInformation {
417
 
        struct {
418
 
                struct policy_handle *handle;/* [ref] */
419
 
                uint32_t level;
420
 
                uint32_t buf_size;/* [range(0,1024)] */
421
 
        } in;
422
 
 
423
 
        struct {
424
 
                uint8_t *buffer;/* [ref,size_is(buf_size)] */
425
 
                uint32_t *bytes_needed;/* [ref] */
426
 
                NTSTATUS result;
427
 
        } out;
428
 
 
429
 
};
430
 
 
431
 
 
432
 
struct eventlog_FlushEventLog {
433
 
        struct {
434
 
                struct policy_handle *handle;/* [ref] */
435
 
        } in;
436
 
 
437
 
        struct {
438
 
                NTSTATUS result;
439
 
        } out;
440
 
 
441
 
};
442
 
 
443
 
 
444
 
struct eventlog_ReportEventAndSourceW {
445
 
        struct {
446
 
                struct policy_handle *handle;/* [ref] */
447
 
                time_t timestamp;
448
 
                enum eventlogEventTypes event_type;
449
 
                uint16_t event_category;
450
 
                uint32_t event_id;
451
 
                struct lsa_String *sourcename;/* [ref] */
452
 
                uint16_t num_of_strings;/* [range(0,256)] */
453
 
                uint32_t data_size;/* [range(0,0x3FFFF)] */
454
 
                struct lsa_String *servername;/* [ref] */
455
 
                struct dom_sid *user_sid;/* [unique] */
456
 
                struct lsa_String **strings;/* [unique,size_is(num_of_strings)] */
457
 
                uint8_t *data;/* [unique,size_is(data_size)] */
458
 
                uint16_t flags;
459
 
                uint32_t *record_number;/* [unique] */
460
 
                time_t *time_written;/* [unique] */
461
 
        } in;
462
 
 
463
 
        struct {
464
 
                uint32_t *record_number;/* [unique] */
465
 
                time_t *time_written;/* [unique] */
466
 
                NTSTATUS result;
467
 
        } out;
468
 
 
469
 
};
470
 
 
471
 
#endif /* _HEADER_eventlog */