← Back to branch summary

~ubuntu-branches/ubuntu/lucid/ndiswrapper/lucid

« back to all changes in this revision

Viewing changes to driver/rtl.c

  • Committer: Bazaar Package Importer
  • Author(s): Timo Aaltonen
  • Date: 2007-03-29 11:04:29 UTC
  • mfrom: (1.2.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20070329110429-x4t1tqrmy867evlk
Tags: 1.38-1ubuntu1
https://launchpad.net/bugs/32275
https://launchpad.net/bugs/65779
https://launchpad.net/bugs/92155
* Merge from debian unstable, remaining changes:
  debian/control:
  - Update description to point out that the kernel source package is
    not required with the standard Ubuntu kernel.
  - Change the Maintainer address.
* Closes many bugs (LP: #32275, #65779, #92155, maybe others)

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver/rtl.c
23
23
/* called when module is being removed */
24
24
void rtl_exit(void)
25
25
{
26
 
        TRACEEXIT4(return);
 
26
        EXIT4(return);
27
27
}
28
28
 
29
29
wstdcall SIZE_T WIN_FUNC(RtlCompareMemory,3)
32
32
        size_t i;
33
33
        char *x, *y;
34
34
 
35
 
        TRACEENTER1("");
 
35
        ENTER1("");
36
36
 
37
37
        x = (char *)a;
38
38
        y = (char *)b;
89
89
        LONG ret = 0;
90
90
        const char *p1, *p2;
91
91
 
92
 
        TRACEENTER2("");
 
92
        ENTER2("");
93
93
        len = min(s1->length, s2->length);
94
94
        p1 = s1->buf;
95
95
        p2 = s2->buf;
101
101
                        ret = *p1++ - *p2++;
102
102
        if (!ret)
103
103
                ret = s1->length - s2->length;
104
 
        TRACEEXIT2(return ret);
 
104
        EXIT2(return ret);
105
105
}
106
106
 
107
107
wstdcall LONG WIN_FUNC(RtlCompareUnicodeString,3)
112
112
        LONG ret = 0;
113
113
        const wchar_t *p1, *p2;
114
114
 
115
 
        TRACEENTER2("");
 
115
        ENTER2("");
116
116
 
117
117
        len = min(s1->length, s2->length) / sizeof(wchar_t);
118
118
        p1 = s1->buf;
125
125
                        ret = (u8)*p1++ - (u8)*p2++;
126
126
        if (!ret)
127
127
                ret = s1->length - s2->length;
128
 
        DBGTRACE2("len: %d, ret: %d", len, ret);
129
 
        TRACEEXIT2(return ret);
 
128
        TRACE2("len: %d, ret: %d", len, ret);
 
129
        EXIT2(return ret);
130
130
}
131
131
 
132
132
wstdcall BOOLEAN WIN_FUNC(RtlEqualString,3)
133
133
        (const struct ansi_string *s1, const struct ansi_string *s2,
134
134
         BOOLEAN case_insensitive)
135
135
{
136
 
        TRACEENTER1("");
 
136
        ENTER1("");
137
137
        if (s1->length != s2->length)
138
138
                return FALSE;
139
139
        return !RtlCompareString(s1, s2, case_insensitive);
151
151
wstdcall void WIN_FUNC(RtlCopyUnicodeString,2)
152
152
        (struct unicode_string *dst, struct unicode_string *src)
153
153
{
154
 
        TRACEENTER1("%p, %p", dst, src);
 
154
        ENTER1("%p, %p", dst, src);
155
155
        if (src && src->buf && dst->buf) {
156
156
                dst->length = min(src->length, dst->max_length);
157
157
                memcpy(dst->buf, src->buf, dst->length);
159
159
                        dst->buf[dst->length / sizeof(dst->buf[0])] = 0;
160
160
        } else
161
161
                dst->length = 0;
162
 
        TRACEEXIT1(return);
 
162
        EXIT1(return);
163
163
}
164
164
 
165
165
wstdcall void WIN_FUNC(RtlCopyString,2)
166
166
        (struct ansi_string *dst, struct ansi_string *src)
167
167
{
168
 
        TRACEENTER1("%p, %p", dst, src);
 
168
        ENTER1("%p, %p", dst, src);
169
169
        if (src && src->buf && dst->buf) {
170
170
                dst->length = min(src->length, dst->max_length);
171
171
                memcpy(dst->buf, src->buf, dst->length);
173
173
                        dst->buf[dst->length] = 0;
174
174
        } else
175
175
                dst->length = 0;
176
 
        TRACEEXIT1(return);
 
176
        EXIT1(return);
177
177
}
178
178
 
179
179
wstdcall NTSTATUS WIN_FUNC(RtlAppendUnicodeToString,2)
204
204
                if (dst->max_length > dst->length)
205
205
                        dst->buf[dst->length / sizeof(dst->buf[0])] = 0;
206
206
        }
207
 
        TRACEEXIT2(return STATUS_SUCCESS);
 
207
        EXIT2(return STATUS_SUCCESS);
208
208
}
209
209
 
210
210
wstdcall ULONG WIN_FUNC(RtlxAnsiStringToUnicodeSize,1)
234
234
        int i, n;
235
235
 
236
236
        n = RtlxAnsiStringToUnicodeSize(src);
237
 
        DBGTRACE2("%d, %d, %d, %d, %p", n, dst->max_length, src->length,
238
 
                  src->max_length, src->buf);
 
237
        TRACE2("%d, %d, %d, %d, %p", n, dst->max_length, src->length,
 
238
               src->max_length, src->buf);
239
239
        if (alloc == TRUE) {
240
240
#if 0
241
241
                if (n == 0) {
242
242
                        dst->length = dst->max_length = 0;
243
243
                        dst->buf = NULL;
244
 
                        TRACEEXIT2(return STATUS_SUCCESS);
 
244
                        EXIT2(return STATUS_SUCCESS);
245
245
                }
246
246
#endif
247
247
                dst->max_length = n + sizeof(dst->buf[0]);
249
249
                                                 dst->max_length, 0);
250
250
                if (!dst->buf) {
251
251
                        dst->max_length = dst->length = 0;
252
 
                        TRACEEXIT2(return STATUS_NO_MEMORY);
 
252
                        EXIT2(return STATUS_NO_MEMORY);
253
253
                }
254
254
        } else if (dst->max_length < n)
255
 
                TRACEEXIT2(return STATUS_BUFFER_TOO_SMALL);
 
255
                EXIT2(return STATUS_BUFFER_TOO_SMALL);
256
256
 
257
257
        dst->length = n;
258
258
        n /= sizeof(dst->buf[0]);
260
260
                dst->buf[i] = src->buf[i];
261
261
        if (i * sizeof(dst->buf[0]) < dst->max_length)
262
262
                dst->buf[i] = 0;
263
 
        DBGTRACE2("dst: length: %d, max_length: %d, string: %p",
264
 
                  dst->length, dst->max_length, src->buf);
265
 
        TRACEEXIT2(return STATUS_SUCCESS);
 
263
        TRACE2("dst: length: %d, max_length: %d, string: %p",
 
264
               dst->length, dst->max_length, src->buf);
 
265
        EXIT2(return STATUS_SUCCESS);
266
266
}
267
267
 
268
268
wstdcall NTSTATUS WIN_FUNC(RtlUnicodeStringToAnsiString,3)
272
272
        int i, n;
273
273
 
274
274
        n = RtlxUnicodeStringToAnsiSize(src);
275
 
        DBGTRACE2("%d, %d, %d, %d, %p", n, dst->max_length, src->length,
276
 
                  src->max_length, src->buf);
 
275
        TRACE2("%d, %d, %d, %d, %p", n, dst->max_length, src->length,
 
276
               src->max_length, src->buf);
277
277
        if (alloc == TRUE) {
278
278
#if 0
279
279
                if (n == 0) {
280
280
                        dst->length = dst->max_length = 0;
281
281
                        dst->buf = NULL;
282
 
                        TRACEEXIT2(return STATUS_SUCCESS);
 
282
                        EXIT2(return STATUS_SUCCESS);
283
283
                }
284
284
#endif
285
285
                dst->max_length = n + sizeof(dst->buf[0]);
287
287
                                                 dst->max_length, 0);
288
288
                if (!dst->buf) {
289
289
                        dst->max_length = dst->length = 0;
290
 
                        TRACEEXIT1(return STATUS_NO_MEMORY);
 
290
                        EXIT1(return STATUS_NO_MEMORY);
291
291
                }
292
292
        } else if (dst->max_length < n)
293
 
                TRACEEXIT2(return STATUS_BUFFER_TOO_SMALL);
 
293
                EXIT2(return STATUS_BUFFER_TOO_SMALL);
294
294
 
295
295
        dst->length = n;
296
296
        for (i = 0; i < n; i++)
297
297
                dst->buf[i] = src->buf[i];
298
298
        if (i < dst->max_length)
299
299
                dst->buf[i] = 0;
300
 
        DBGTRACE2("string: %p, len: %d(%d)", dst->buf, dst->length,
301
 
                  dst->max_length);
302
 
        TRACEEXIT2(return STATUS_SUCCESS);
 
300
        TRACE2("string: %p, len: %d(%d)", dst->buf, dst->length,
 
301
               dst->max_length);
 
302
        EXIT2(return STATUS_SUCCESS);
303
303
}
304
304
 
305
305
wstdcall NTSTATUS WIN_FUNC(RtlUnicodeStringToInteger,3)
424
424
                char *c = (char *)&dst->buf[i];
425
425
                *c = toupper(src->buf[i]);
426
426
        }
427
 
        TRACEEXIT3(return STATUS_SUCCESS);
 
427
        EXIT3(return STATUS_SUCCESS);
428
428
}
429
429
 
430
430
wstdcall void WIN_FUNC(RtlInitUnicodeString,2)
431
431
        (struct unicode_string *dst, const wchar_t *src)
432
432
{
433
 
        TRACEENTER2("%p", dst);
 
433
        ENTER2("%p", dst);
434
434
        if (dst == NULL)
435
 
                TRACEEXIT1(return);
 
435
                EXIT1(return);
436
436
        if (src == NULL) {
437
437
                dst->max_length = dst->length = 0;
438
438
                dst->buf = NULL;
444
444
                dst->length = i * sizeof(dst->buf[0]);
445
445
                dst->max_length = (i + 1) * sizeof(dst->buf[0]);
446
446
        }
447
 
        TRACEEXIT1(return);
 
447
        EXIT1(return);
448
448
}
449
449
 
450
450
wstdcall void WIN_FUNC(RtlInitAnsiString,2)
451
451
        (struct ansi_string *dst, const char *src)
452
452
{
453
 
        TRACEENTER2("%p", dst);
 
453
        ENTER2("%p", dst);
454
454
        if (dst == NULL)
455
 
                TRACEEXIT2(return);
 
455
                EXIT2(return);
456
456
        if (src == NULL) {
457
457
                dst->max_length = dst->length = 0;
458
458
                dst->buf = NULL;
464
464
                dst->length = i;
465
465
                dst->max_length = i + 1;
466
466
        }
467
 
        DBGTRACE2("%p", dst->buf);
468
 
        TRACEEXIT2(return);
 
467
        TRACE2("%p", dst->buf);
 
468
        EXIT2(return);
469
469
}
470
470
 
471
471
wstdcall void WIN_FUNC(RtlInitString,2)
472
472
        (struct ansi_string *dst, const char *src)
473
473
{
474
 
        TRACEENTER2("%p", dst);
 
474
        ENTER2("%p", dst);
475
475
        RtlInitAnsiString(dst, src);
476
 
        TRACEEXIT2(return);
 
476
        EXIT2(return);
477
477
}
478
478
 
479
479
wstdcall void WIN_FUNC(RtlFreeUnicodeString,1)
480
480
        (struct unicode_string *string)
481
481
{
482
 
        TRACEENTER2("%p", string);
 
482
        ENTER2("%p", string);
483
483
        if (string == NULL)
484
484
                return;
485
485
        if (string->buf)
492
492
wstdcall void WIN_FUNC(RtlFreeAnsiString,1)
493
493
        (struct ansi_string *string)
494
494
{
495
 
        TRACEENTER2("%p", string);
 
495
        ENTER2("%p", string);
496
496
        if (string == NULL)
497
497
                return;
498
498
        if (string->buf)
518
518
            ansi.buf[14] != '-' || ansi.buf[19] != '-' ||
519
519
            ansi.buf[24] != '-') {
520
520
                RtlFreeAnsiString(&ansi);
521
 
                TRACEEXIT2(return STATUS_INVALID_PARAMETER);
 
521
                EXIT2(return STATUS_INVALID_PARAMETER);
522
522
        }
523
523
        memcpy(&guid->data4, &ansi.buf[29], sizeof(guid->data3));
524
524
        /* set end of data3 for scanf */
547
547
        NTSTATUS status, ret;
548
548
        static int i = 0;
549
549
 
550
 
        TRACEENTER3("%x, %p", relative, tbl);
 
550
        ENTER3("%x, %p", relative, tbl);
551
551
//      TODO();
552
552
 
553
553
        RtlInitUnicodeString(&unicode, path);
554
554
        if (RtlUnicodeStringToAnsiString(&ansi, &unicode, TRUE) ==
555
555
            STATUS_SUCCESS) {
556
 
                DBGTRACE2("%s", ansi.buf);
 
556
                TRACE2("%s", ansi.buf);
557
557
                RtlFreeAnsiString(&ansi);
558
558
        }
559
559
        ret = STATUS_SUCCESS;
561
561
                RtlInitUnicodeString(&unicode, tbl->name);
562
562
                if (RtlUnicodeStringToAnsiString(&ansi, &unicode, TRUE) ==
563
563
                    STATUS_SUCCESS) {
564
 
                        DBGTRACE2("name: %s", ansi.buf);
 
564
                        TRACE2("name: %s", ansi.buf);
565
565
                        RtlFreeAnsiString(&ansi);
566
566
                }
567
 
                DBGTRACE2("flags: %08X", tbl->flags);
 
567
                TRACE2("flags: %08X", tbl->flags);
568
568
                if (tbl->flags == RTL_QUERY_REGISTRY_DIRECT) {
569
 
                        DBGTRACE2("type: %08X", tbl->def_type);
 
569
                        TRACE2("type: %08X", tbl->def_type);
570
570
                        if (tbl->def_type == REG_DWORD) {
571
571
                                /* Atheros USB driver needs this, but
572
572
                                 * don't know where and how to get its
573
573
                                 * value */
574
574
                                if (tbl->def_data) {
575
 
                                        DBGTRACE2("def_data: %x",
576
 
                                                  *(int *)tbl->def_data);
 
575
                                        TRACE2("def_data: %x",
 
576
                                               *(int *)tbl->def_data);
577
577
                                        *(DWORD *)tbl->context = 0x5f292a + i++;
578
578
//                                              *(DWORD *)tbl->def_data;
579
579
                                } else
597
597
                                type = tbl->def_type;
598
598
                                length = tbl->def_length;;
599
599
                        }
600
 
                        DBGTRACE2("calling query_func: %p", tbl->query_func);
 
600
                        TRACE2("calling query_func: %p", tbl->query_func);
601
601
                        status = LIN2WIN6(tbl->query_func, tbl->name, type,
602
602
                                          data, length, context, env);
603
 
                        DBGTRACE2("status: %08X", status);
 
603
                        TRACE2("status: %08X", status);
604
604
                        if (status) {
605
605
                                if (status == STATUS_BUFFER_TOO_SMALL)
606
606
                                        ret = STATUS_BUFFER_TOO_SMALL;
607
607
                                else
608
 
                                        TRACEEXIT2(return STATUS_INVALID_PARAMETER);
 
608
                                        EXIT2(return STATUS_INVALID_PARAMETER);
609
609
                        }
610
610
                }
611
611
        }
612
 
        TRACEEXIT3(return ret);
 
612
        EXIT3(return ret);
613
613
}
614
614
 
615
615
wstdcall NTSTATUS WIN_FUNC(RtlWriteRegistryValue,6)
619
619
        struct ansi_string ansi;
620
620
        struct unicode_string unicode;
621
621
 
622
 
        TRACEENTER3("%d", relative);
 
622
        ENTER3("%d", relative);
623
623
        TODO();
624
624
 
625
625
        RtlInitUnicodeString(&unicode, path);
626
626
        if (RtlUnicodeStringToAnsiString(&ansi, &unicode, TRUE) ==
627
627
            STATUS_SUCCESS) {
628
 
                DBGTRACE2("%s", ansi.buf);
 
628
                TRACE2("%s", ansi.buf);
629
629
                RtlFreeAnsiString(&ansi);
630
630
        }
631
631
        RtlInitUnicodeString(&unicode, name);
632
632
        if (RtlUnicodeStringToAnsiString(&ansi, &unicode, TRUE) ==
633
633
            STATUS_SUCCESS) {
634
 
                DBGTRACE2("%s", ansi.buf);
 
634
                TRACE2("%s", ansi.buf);
635
635
                RtlFreeAnsiString(&ansi);
636
636
        }
637
 
        TRACEEXIT5(return STATUS_SUCCESS);
 
637
        EXIT5(return STATUS_SUCCESS);
638
638
}
639
639
 
640
640
wstdcall NTSTATUS WIN_FUNC(RtlDeleteRegistryValue,3)