00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
#include <stdio.h>
00036
#include <stdlib.h>
00037
#include <sys/types.h>
00038
#include <fcntl.h>
00039
#include <string.h>
00040
#include <unistd.h>
00041
#include "dazukoio_xp.h"
00042
#include "dazukoio.h"
00043
00044
#if !defined(NO_COMPAT12)
00045
#include "dazukoio_compat12.h"
00046
#endif
00047
00048 #define ITOA_SIZE 32
00049
00050 dazuko_id_t *
_GLOBAL_DAZUKO =
NULL;
00051
00052
#if !defined(NO_COMPAT12)
00053 char _GLOBAL_DAZUKO_COMPAT12 = 0;
00054
#endif
00055
00056 static inline char char_to_hex(
char c)
00057 {
00058
00059
00060
switch (c)
00061 {
00062
case '1':
return 1;
00063
case '2':
return 2;
00064
case '3':
return 3;
00065
case '4':
return 4;
00066
case '5':
return 5;
00067
case '6':
return 6;
00068
case '7':
return 7;
00069
case '8':
return 8;
00070
case '9':
return 9;
00071
case 'a':
case 'A':
return 10;
00072
case 'b':
case 'B':
return 11;
00073
case 'c':
case 'C':
return 12;
00074
case 'd':
case 'D':
return 13;
00075
case 'e':
case 'E':
return 14;
00076
case 'f':
case 'F':
return 15;
00077 }
00078
00079
return 0;
00080 }
00081
00082 static void unescape_string(
char *string)
00083 {
00084
char *p;
00085
00086
for (p=string ; *p ; p++)
00087 {
00088
00089
if ((*p ==
'\\') && (*(p+1) ==
'x'))
00090 {
00091
00092
00093
00094
if (*(p+2) && *(p+3))
00095 {
00096 *p =
char_to_hex(*(p+2));
00097 *p <<= 4;
00098 *p |=
char_to_hex(*(p+3));
00099
00100 memmove(p + 1, p + 4, strlen(p+4) + 1);
00101 }
00102 }
00103 }
00104 }
00105
00106 static int get_value(
const char *key,
const char *string,
char *buffer, size_t buffer_size)
00107 {
00108
const char *p1;
00109
const char *p2;
00110 size_t size;
00111
00112
if (buffer ==
NULL || buffer_size < 1)
00113
return -1;
00114
00115 buffer[0] = 0;
00116
00117
if (key ==
NULL || string ==
NULL)
00118
return -1;
00119
00120 p1 = strstr(string, key);
00121
if (p1 ==
NULL)
00122
return -1;
00123
00124 p1 += strlen(key);
00125
00126
for (p2=p1 ; *p2 && *p2!=
'\n' ; p2++)
00127
continue;
00128
00129 size = p2 - p1;
00130
if (size >= buffer_size)
00131 size = buffer_size - 1;
00132
00133 memcpy(buffer, p1, size);
00134
00135 buffer[size] = 0;
00136
00137
return 0;
00138 }
00139
00140 int dazukoRegister(
const char *groupName,
const char *mode)
00141 {
00142
return dazukoRegister_TS(&
_GLOBAL_DAZUKO, groupName, mode);
00143 }
00144
00145 int dazukoRegister_TS(
dazuko_id_t **
dazuko_id,
const char *groupName,
const char *mode)
00146 {
00147
struct dazuko_request *request;
00148
char buffer[
ITOA_SIZE];
00149
char regMode[3];
00150
dazuko_id_t *temp_id;
00151 ssize_t size;
00152
int write_mode = 0;
00153
#if !defined(NO_COMPAT12)
00154
int compat12_ret;
00155
#endif
00156
00157
if (dazuko_id ==
NULL)
00158
return -1;
00159
00160
00161
if (groupName ==
NULL)
00162 groupName =
"_GENERIC";
00163
00164
00165
if (mode ==
NULL)
00166 mode =
"r";
00167
00168
if (strcasecmp(mode,
"r") == 0)
00169 {
00170 strncpy(regMode,
"R",
sizeof(regMode));
00171 write_mode = 0;
00172 }
00173
else if (strcasecmp(mode,
"r+") == 0 || strcasecmp(mode,
"rw") == 0)
00174 {
00175 strncpy(regMode,
"RW",
sizeof(regMode));
00176 write_mode = 1;
00177 }
00178
else
00179 {
00180
return -1;
00181 }
00182 regMode[
sizeof(regMode) - 1] = 0;
00183
00184
#if !defined(NO_COMPAT12)
00185
if (
_GLOBAL_DAZUKO_COMPAT12)
00186 {
00187 compat12_ret =
dazukoRegister_TS_compat12_wrapper(dazuko_id, groupName);
00188
00189
if (compat12_ret == 0)
00190 (*dazuko_id)->write_mode = write_mode;
00191
00192
return compat12_ret;
00193 }
00194
#endif
00195
00196
00197 temp_id = (
dazuko_id_t *)malloc(
sizeof(*temp_id));
00198
if (temp_id ==
NULL)
00199
return -1;
00200
00201 memset(temp_id, 0,
sizeof(*temp_id));
00202
00203
00204 temp_id->device = open(
"/dev/dazuko", O_RDWR);
00205
if (temp_id->device < 0)
00206 {
00207 free(temp_id);
00208
return -1;
00209 }
00210
00211
00212 memset(buffer, 0,
sizeof(buffer));
00213
if (read(temp_id->device, buffer,
sizeof(buffer)-1) < 1)
00214 {
00215 close(temp_id->device);
00216 free(temp_id);
00217
return -1;
00218 }
00219
00220 temp_id->dev_major = atoi(buffer);
00221
if (temp_id->dev_major < 0)
00222 {
00223 close(temp_id->device);
00224 free(temp_id);
00225
return -1;
00226 }
00227
00228 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00229
if (request ==
NULL)
00230 {
00231 close(temp_id->device);
00232 free(temp_id);
00233
return -1;
00234 }
00235
00236 memset(request, 0,
sizeof(*request));
00237
00238 request->type[0] =
REGISTER;
00239
00240 size = 1 + 2 + 1 + strlen(regMode);
00241 size += 1 + 2 + 1 + strlen(groupName);
00242 size += 1;
00243
00244 request->buffer = (
char *)malloc(size);
00245
if (request->buffer ==
NULL)
00246 {
00247 close(temp_id->device);
00248 free(temp_id);
00249 free(request);
00250
return -1;
00251 }
00252 snprintf(request->buffer, size,
"\nRM=%s\nGN=%s", regMode, groupName);
00253 request->buffer[size - 1] = 0;
00254
00255 request->buffer_size = strlen(request->buffer) + 1;
00256
00257 size = 4096;
00258 request->reply_buffer = (
char *)malloc(size);
00259
if (request->reply_buffer ==
NULL)
00260 {
00261 close(temp_id->device);
00262 free(temp_id);
00263 free(request->buffer);
00264 free(request);
00265
return -1;
00266 }
00267 memset(request->reply_buffer, 0, size);
00268 request->reply_buffer_size = size;
00269
00270 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00271 buffer[
sizeof(buffer)-1] = 0;
00272 size = strlen(buffer) + 1;
00273
00274
if (write(temp_id->device, buffer, size) != size)
00275 {
00276 close(temp_id->device);
00277 free(temp_id);
00278 free(request->buffer);
00279 free(request->reply_buffer);
00280 free(request);
00281
00282
#if !defined(NO_COMPAT12)
00283
00284 compat12_ret =
dazukoRegister_TS_compat12_wrapper(dazuko_id, groupName);
00285
if (compat12_ret == 0)
00286 {
00287 (*dazuko_id)->write_mode = write_mode;
00288
_GLOBAL_DAZUKO_COMPAT12 = 1;
00289 }
00290
00291
return compat12_ret;
00292
#else
00293
return -1;
00294
#endif
00295
}
00296
00297
if (
get_value(
"\nID=", request->reply_buffer, buffer,
sizeof(buffer)) != 0)
00298 {
00299 close(temp_id->device);
00300 free(temp_id);
00301 free(request->buffer);
00302 free(request->reply_buffer);
00303 free(request);
00304
00305
#if !defined(NO_COMPAT12)
00306
00307 compat12_ret =
dazukoRegister_TS_compat12_wrapper(dazuko_id, groupName);
00308
if (compat12_ret == 0)
00309 {
00310 (*dazuko_id)->write_mode = write_mode;
00311
_GLOBAL_DAZUKO_COMPAT12 = 1;
00312 }
00313
00314
return compat12_ret;
00315
#else
00316
return -1;
00317
#endif
00318
}
00319
00320 temp_id->id = atoi(buffer);
00321
00322
if (temp_id->id < 0)
00323 {
00324 free(request->buffer);
00325 free(request->reply_buffer);
00326 free(request);
00327
00328
return -1;
00329 }
00330
00331 temp_id->write_mode = write_mode;
00332
00333 free(request->buffer);
00334 free(request->reply_buffer);
00335 free(request);
00336
00337 *dazuko_id = temp_id;
00338
00339
return 0;
00340 }
00341
00342 int dazukoSetAccessMask(
unsigned long accessMask)
00343 {
00344
return dazukoSetAccessMask_TS(
_GLOBAL_DAZUKO, accessMask);
00345 }
00346
00347 int dazukoSetAccessMask_TS(
dazuko_id_t *
dazuko_id,
unsigned long accessMask)
00348 {
00349
struct dazuko_request *request;
00350 ssize_t size;
00351
char buffer[
ITOA_SIZE];
00352
00353
if (dazuko_id ==
NULL)
00354
return -1;
00355
00356
#if !defined(NO_COMPAT12)
00357
if (
_GLOBAL_DAZUKO_COMPAT12)
00358
return dazukoSetAccessMask_TS_compat12(dazuko_id, accessMask);
00359
#endif
00360
00361
if (dazuko_id->
device < 0 || dazuko_id->
dev_major < 0 || dazuko_id->
id < 0)
00362
return -1;
00363
00364 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00365
if (request ==
NULL)
00366
return -1;
00367
00368 memset(request, 0,
sizeof(*request));
00369
00370 request->type[0] =
SET_ACCESS_MASK;
00371
00372 size = 1 + 2 + 1 +
ITOA_SIZE;
00373 size += 1 + 2 + 1 +
ITOA_SIZE;
00374 size += 1;
00375
00376 request->buffer = (
char *)malloc(size);
00377
if (request->buffer ==
NULL)
00378 {
00379 free(request);
00380
return -1;
00381 }
00382 snprintf(request->buffer, size,
"\nID=%d\nAM=%lu", dazuko_id->
id, accessMask);
00383 request->buffer[size - 1] = 0;
00384
00385 request->buffer_size = strlen(request->buffer) + 1;
00386
00387 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00388 buffer[
sizeof(buffer)-1] = 0;
00389 size = strlen(buffer) + 1;
00390
00391
if (write(dazuko_id->
device, buffer, size) != size)
00392 {
00393 free(request->buffer);
00394 free(request);
00395
return -1;
00396 }
00397
00398 free(request->buffer);
00399 free(request);
00400
00401
return 0;
00402 }
00403
00404 static int dazuko_set_path(
dazuko_id_t *
dazuko_id,
const char *
path,
int type)
00405 {
00406
struct dazuko_request *request;
00407 ssize_t size;
00408
char buffer[
ITOA_SIZE];
00409
00410
if (dazuko_id ==
NULL)
00411
return -1;
00412
00413
if (dazuko_id->
device < 0 || dazuko_id->
dev_major < 0 || dazuko_id->
id < 0)
00414
return -1;
00415
00416
if (path ==
NULL)
00417
return -1;
00418
00419 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00420
if (request ==
NULL)
00421
return -1;
00422
00423 memset(request, 0,
sizeof(*request));
00424
00425 request->type[0] = type;
00426
00427 size = 1 + 2 + 1 +
ITOA_SIZE;
00428 size += 1 + 2 + 1 + strlen(path);
00429 size += 1;
00430
00431 request->buffer = (
char *)malloc(size);
00432
if (request->buffer ==
NULL)
00433 {
00434 free(request);
00435
return -1;
00436 }
00437 snprintf(request->buffer, size,
"\nID=%d\nPT=%s", dazuko_id->
id, path);
00438 request->buffer[size - 1] = 0;
00439
00440 request->buffer_size = strlen(request->buffer) + 1;
00441
00442 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00443 buffer[
sizeof(buffer)-1] = 0;
00444 size = strlen(buffer) + 1;
00445
00446
if (write(dazuko_id->
device, buffer, size) != size)
00447 {
00448 free(request->buffer);
00449 free(request);
00450
return -1;
00451 }
00452
00453 free(request->buffer);
00454 free(request);
00455
00456
return 0;
00457 }
00458
00459 int dazukoAddIncludePath(
const char *
path)
00460 {
00461
return dazukoAddIncludePath_TS(
_GLOBAL_DAZUKO, path);
00462 }
00463
00464 int dazukoAddIncludePath_TS(
dazuko_id_t *
dazuko_id,
const char *
path)
00465 {
00466
#if !defined(NO_COMPAT12)
00467
if (
_GLOBAL_DAZUKO_COMPAT12)
00468
return dazukoAddIncludePath_TS_compat12(dazuko_id, path);
00469
#endif
00470
00471
return dazuko_set_path(dazuko_id, path,
ADD_INCLUDE_PATH);
00472 }
00473
00474 int dazukoAddExcludePath(
const char *
path)
00475 {
00476
return dazukoAddExcludePath_TS(
_GLOBAL_DAZUKO, path);
00477 }
00478
00479 int dazukoAddExcludePath_TS(
dazuko_id_t *
dazuko_id,
const char *
path)
00480 {
00481
#if !defined(NO_COMPAT12)
00482
if (
_GLOBAL_DAZUKO_COMPAT12)
00483
return dazukoAddExcludePath_TS_compat12(dazuko_id, path);
00484
#endif
00485
00486
return dazuko_set_path(dazuko_id, path,
ADD_EXCLUDE_PATH);
00487 }
00488
00489 int dazukoRemoveAllPaths(
void)
00490 {
00491
return dazukoRemoveAllPaths_TS(
_GLOBAL_DAZUKO);
00492 }
00493
00494 int dazukoRemoveAllPaths_TS(
dazuko_id_t *
dazuko_id)
00495 {
00496
struct dazuko_request *request;
00497 ssize_t size;
00498
char buffer[
ITOA_SIZE];
00499
00500
if (dazuko_id ==
NULL)
00501
return -1;
00502
00503
#if !defined(NO_COMPAT12)
00504
if (
_GLOBAL_DAZUKO_COMPAT12)
00505
return dazukoRemoveAllPaths_TS_compat12(dazuko_id);
00506
#endif
00507
00508
if (dazuko_id->
device < 0 || dazuko_id->
dev_major < 0 || dazuko_id->
id < 0)
00509
return -1;
00510
00511 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00512
if (request ==
NULL)
00513
return -1;
00514
00515 memset(request, 0,
sizeof(*request));
00516
00517 request->type[0] =
REMOVE_ALL_PATHS;
00518
00519 size = 1 + 2 + 1 +
ITOA_SIZE;
00520 size += 1;
00521
00522 request->buffer = (
char *)malloc(size);
00523
if (request->buffer ==
NULL)
00524 {
00525 free(request);
00526
return -1;
00527 }
00528 snprintf(request->buffer, size,
"\nID=%d", dazuko_id->
id);
00529 request->buffer[size - 1] = 0;
00530
00531 request->buffer_size = strlen(request->buffer) + 1;
00532
00533 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00534 buffer[
sizeof(buffer)-1] = 0;
00535 size = strlen(buffer) + 1;
00536
00537
if (write(dazuko_id->
device, buffer, size) != size)
00538 {
00539 free(request->buffer);
00540 free(request);
00541
return -1;
00542 }
00543
00544 free(request->buffer);
00545 free(request);
00546
00547
return 0;
00548 }
00549
00550 int dazukoGetAccess(
struct dazuko_access **acc)
00551 {
00552
return dazukoGetAccess_TS(
_GLOBAL_DAZUKO, acc);
00553 }
00554
00555 int dazukoGetAccess_TS(
dazuko_id_t *
dazuko_id,
struct dazuko_access **acc)
00556 {
00557
struct dazuko_request *request;
00558
struct dazuko_access *temp_acc;
00559 ssize_t size;
00560 size_t filename_size;
00561
char buffer[
ITOA_SIZE];
00562
#if !defined(NO_COMPAT12)
00563
int compat12_ret;
00564
#endif
00565
00566
if (dazuko_id ==
NULL)
00567
return -1;
00568
00569
#if !defined(NO_COMPAT12)
00570
if (
_GLOBAL_DAZUKO_COMPAT12)
00571 {
00572 compat12_ret =
dazukoGetAccess_TS_compat12_wrapper(dazuko_id, acc);
00573
00574
if (compat12_ret == 0 && !(dazuko_id->
write_mode))
00575 {
00576
00577
00578
dazukoReturnAccess_TS_compat12_wrapper(dazuko_id, acc, 1, 0);
00579
00580
00581 }
00582
00583
return compat12_ret;
00584 }
00585
#endif
00586
00587
if (dazuko_id->
device < 0 || dazuko_id->
dev_major < 0 || dazuko_id->
id < 0)
00588
return -1;
00589
00590
if (acc ==
NULL)
00591
return -1;
00592
00593 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00594
if (request ==
NULL)
00595
return -1;
00596
00597 memset(request, 0,
sizeof(*request));
00598
00599 request->type[0] =
GET_AN_ACCESS;
00600
00601 size = 1 + 2 + 1 +
ITOA_SIZE;
00602 size += 1;
00603
00604 request->buffer = (
char *)malloc(size);
00605
if (request->buffer ==
NULL)
00606 {
00607 free(request);
00608
return -1;
00609 }
00610 snprintf(request->buffer, size,
"\nID=%d", dazuko_id->
id);
00611 request->buffer[size - 1] = 0;
00612
00613 request->buffer_size = strlen(request->buffer) + 1;
00614
00615 size = 1 + 2 + 1 +
DAZUKO_FILENAME_MAX_LENGTH;
00616 size += 1024;
00617 size += 1;
00618 request->reply_buffer = (
char *)malloc(size);
00619
if (request->reply_buffer ==
NULL)
00620 {
00621 free(request->buffer);
00622 free(request);
00623
return -1;
00624 }
00625 memset(request->reply_buffer, 0, size);
00626 request->reply_buffer_size = size;
00627
00628 temp_acc = (
struct dazuko_access *)malloc(
sizeof(*temp_acc));
00629
if (temp_acc ==
NULL)
00630 {
00631 free(request->reply_buffer);
00632 free(request->buffer);
00633 free(request);
00634
return -1;
00635 }
00636
00637 memset(temp_acc, 0,
sizeof(*temp_acc));
00638
00639 filename_size =
DAZUKO_FILENAME_MAX_LENGTH + 1;
00640 temp_acc->filename = (
char *)malloc(filename_size);
00641
if (temp_acc->filename ==
NULL)
00642 {
00643 free(temp_acc);
00644 free(request->reply_buffer);
00645 free(request->buffer);
00646 free(request);
00647
return -1;
00648 }
00649
00650 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00651 buffer[
sizeof(buffer)-1] = 0;
00652 size = strlen(buffer) + 1;
00653
00654
if (write(dazuko_id->
device, buffer, size) != size)
00655 {
00656 free(temp_acc->filename);
00657 free(temp_acc);
00658 free(request->reply_buffer);
00659 free(request->buffer);
00660 free(request);
00661
return -1;
00662 }
00663
00664
if (request->reply_buffer_size_used > 0)
00665 {
00666
if (
get_value(
"\nFN=", request->reply_buffer, temp_acc->filename, filename_size) == 0)
00667 {
00668 temp_acc->set_filename = 1;
00669
unescape_string(temp_acc->filename);
00670 }
00671
00672
if (
get_value(
"\nEV=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00673 {
00674 temp_acc->event = atoi(buffer);
00675 temp_acc->set_event = 1;
00676 }
00677
00678
if (
get_value(
"\nFL=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00679 {
00680 temp_acc->flags = atoi(buffer);
00681 temp_acc->set_flags = 1;
00682 }
00683
00684
if (
get_value(
"\nMD=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00685 {
00686 temp_acc->mode = atoi(buffer);
00687 temp_acc->set_mode = 1;
00688 }
00689
00690
if (
get_value(
"\nUI=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00691 {
00692 temp_acc->uid = atoi(buffer);
00693 temp_acc->set_uid = 1;
00694 }
00695
00696
if (
get_value(
"\nPI=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00697 {
00698 temp_acc->pid = atoi(buffer);
00699 temp_acc->set_pid = 1;
00700 }
00701
00702
if (
get_value(
"\nFS=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00703 {
00704 temp_acc->file_size = atol(buffer);
00705 temp_acc->set_file_size = 1;
00706 }
00707
00708
if (
get_value(
"\nFU=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00709 {
00710 temp_acc->file_uid = atoi(buffer);
00711 temp_acc->set_file_uid = 1;
00712 }
00713
00714
if (
get_value(
"\nFG=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00715 {
00716 temp_acc->file_gid = atoi(buffer);
00717 temp_acc->set_file_gid = 1;
00718 }
00719
00720
if (
get_value(
"\nDT=", request->reply_buffer, buffer,
sizeof(buffer)) == 0)
00721 {
00722 temp_acc->file_device = atoi(buffer);
00723 temp_acc->set_file_device = 1;
00724 }
00725 }
00726
00727 free(request->reply_buffer);
00728 free(request->buffer);
00729 free(request);
00730
00731 *acc = temp_acc;
00732
00733
return 0;
00734 }
00735
00736 int dazukoReturnAccess(
struct dazuko_access **acc)
00737 {
00738
return dazukoReturnAccess_TS(
_GLOBAL_DAZUKO, acc);
00739 }
00740
00741 int dazukoReturnAccess_TS(
dazuko_id_t *
dazuko_id,
struct dazuko_access **acc)
00742 {
00743
struct dazuko_request *request;
00744 ssize_t size;
00745
char buffer[
ITOA_SIZE];
00746
00747
if (dazuko_id ==
NULL)
00748
return -1;
00749
00750
#if !defined(NO_COMPAT12)
00751
if (
_GLOBAL_DAZUKO_COMPAT12)
00752
return dazukoReturnAccess_TS_compat12_wrapper(dazuko_id, acc, dazuko_id->
write_mode, 1);
00753
#endif
00754
00755
if (dazuko_id->
device < 0 || dazuko_id->
dev_major < 0 || dazuko_id->
id < 0)
00756
return -1;
00757
00758
if (acc ==
NULL)
00759
return -1;
00760
00761
if (*acc ==
NULL)
00762
return -1;
00763
00764
if (dazuko_id->
write_mode)
00765 {
00766 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00767
if (request ==
NULL)
00768
return -1;
00769
00770 memset(request, 0,
sizeof(*request));
00771
00772 request->type[0] =
RETURN_AN_ACCESS;
00773
00774 size = 1 + 2 + 1 +
ITOA_SIZE;
00775 size += 1 + 2 + 1 +
ITOA_SIZE;
00776 size += 1;
00777
00778 request->buffer = (
char *)malloc(size);
00779
if (request->buffer ==
NULL)
00780 {
00781 free(request);
00782
return -1;
00783 }
00784 snprintf(request->buffer, size,
"\nID=%d\nDN=%d", dazuko_id->
id, (*acc)->deny == 0 ? 0 : 1);
00785 request->buffer[size - 1] = 0;
00786
00787 request->buffer_size = strlen(request->buffer) + 1;
00788
00789 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00790 buffer[
sizeof(buffer)-1] = 0;
00791 size = strlen(buffer) + 1;
00792
00793
if (write(dazuko_id->
device, buffer, size) != size)
00794 {
00795
00796
00797
if ((*acc)->filename !=
NULL)
00798 free((*acc)->filename);
00799 free(*acc);
00800 *acc =
NULL;
00801 free(request->buffer);
00802 free(request);
00803
return -1;
00804 }
00805
00806 free(request->buffer);
00807 free(request);
00808 }
00809
00810
if ((*acc)->filename !=
NULL)
00811 free((*acc)->filename);
00812 free(*acc);
00813 *acc =
NULL;
00814
00815
return 0;
00816 }
00817
00818 int dazukoUnregister(
void)
00819 {
00820
return dazukoUnregister_TS(&
_GLOBAL_DAZUKO);
00821 }
00822
00823 int dazukoUnregister_TS(
dazuko_id_t **
dazuko_id)
00824 {
00825
struct dazuko_request *request;
00826 ssize_t size;
00827
char buffer[
ITOA_SIZE];
00828
00829
if (dazuko_id ==
NULL)
00830
return -1;
00831
00832
#if !defined(NO_COMPAT12)
00833
if (
_GLOBAL_DAZUKO_COMPAT12)
00834
return dazukoUnregister_TS_compat12_wrapper(dazuko_id);
00835
#endif
00836
00837
if (*dazuko_id ==
NULL)
00838
return -1;
00839
00840
if ((*dazuko_id)->device < 0)
00841
return -1;
00842
00843
if ((*dazuko_id)->dev_major >= 0 && (*dazuko_id)->id >= 0)
00844 {
00845 request = (
struct dazuko_request *)malloc(
sizeof(*request));
00846
if (request ==
NULL)
00847
return -1;
00848
00849 memset(request, 0,
sizeof(*request));
00850
00851 request->type[0] =
UNREGISTER;
00852
00853 size = 1 + 2 + 1 +
ITOA_SIZE;
00854 size += 1;
00855
00856 request->buffer = (
char *)malloc(size);
00857
if (request->buffer ==
NULL)
00858 {
00859 free(request);
00860
return -1;
00861 }
00862 snprintf(request->buffer, size,
"\nID=%d", (*dazuko_id)->id);
00863 request->buffer[size - 1] = 0;
00864
00865 request->buffer_size = strlen(request->buffer) + 1;
00866
00867 snprintf(buffer,
sizeof(buffer),
"\nRA=%lu", (
unsigned long)request);
00868 buffer[
sizeof(buffer)-1] = 0;
00869 size = strlen(buffer) + 1;
00870
00871
if (write((*dazuko_id)->device, buffer, size) != size)
00872 {
00873
00874
00875 close((*dazuko_id)->device);
00876 free(*dazuko_id);
00877 *dazuko_id =
NULL;
00878 free(request->buffer);
00879 free(request);
00880
return -1;
00881 }
00882
00883 free(request->buffer);
00884 free(request);
00885 }
00886
00887 close((*dazuko_id)->device);
00888 free(*dazuko_id);
00889 *dazuko_id =
NULL;
00890
00891
return 0;
00892 }