/daten/src/linux-2.4.27-rsbac-v1.2.3/rsbac/adf/daz/dazukoio.c

Go to the documentation of this file.
00001 /* Dazuko Interface. Interace with Dazuko for file access control. 00002 Written by John Ogness <jogness@antivir.de> 00003 00004 Copyright (c) 2002, 2003 H+BEDV Datentechnik GmbH 00005 All rights reserved. 00006 00007 Redistribution and use in source and binary forms, with or without 00008 modification, are permitted provided that the following conditions 00009 are met: 00010 00011 1. Redistributions of source code must retain the above copyright notice, 00012 this list of conditions and the following disclaimer. 00013 00014 2. Redistributions in binary form must reproduce the above copyright notice, 00015 this list of conditions and the following disclaimer in the documentation 00016 and/or other materials provided with the distribution. 00017 00018 3. Neither the name of Dazuko nor the names of its contributors may be used 00019 to endorse or promote products derived from this software without specific 00020 prior written permission. 00021 00022 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00023 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00024 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 00025 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 00026 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 00027 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 00028 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 00029 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 00030 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 00031 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 00032 POSSIBILITY OF SUCH DAMAGE. 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 /* ugly, but fast */ 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 /* check if we have \x */ 00089 if ((*p == '\\') && (*(p+1) == 'x')) 00090 { 00091 /* this is not cheap, but it should not occur often */ 00092 00093 /* check if we have two more values following \x */ 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 /* set default group name if one was not given */ 00161 if (groupName == NULL) 00162 groupName = "_GENERIC"; 00163 00164 /* set default mode if one was not given */ 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 /* create temporary id */ 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 /* open device */ 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 /* read device major number */ 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); /* \nRM=mode */ 00241 size += 1 + 2 + 1 + strlen(groupName); /* \nGN=groupName */ 00242 size += 1; /* \0 */ 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 /* we try compat12 mode */ 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 /* we try compat12 mode */ 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; /* \nID=id */ 00373 size += 1 + 2 + 1 + ITOA_SIZE; /* \nAM=accessMask */ 00374 size += 1; /* \0 */ 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; /* \nID=id */ 00428 size += 1 + 2 + 1 + strlen(path); /* \nPT=path */ 00429 size += 1; /* \0 */ 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; /* \nID=id */ 00520 size += 1; /* \0 */ 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 /* we are in read_only mode so we return the access immediately */ 00577 00578 dazukoReturnAccess_TS_compat12_wrapper(dazuko_id, acc, 1, 0); 00579 00580 /* this could be dangerous, we do not check if the return was successfull! */ 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; /* \nID=id */ 00602 size += 1; /* \0 */ 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; /* \nFN=filename */ 00616 size += 1024; /* miscellaneous access attributes */ 00617 size += 1; /* \0 */ 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; /* \nID=id */ 00775 size += 1 + 2 + 1 + ITOA_SIZE; /* \nDN=deny */ 00776 size += 1; /* \0 */ 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 /* there could be big problems if this happens */ 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; /* \nID=id */ 00854 size += 1; /* \0 */ 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 /* there could be big problems if this happens */ 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 }

Generated on Tue Aug 31 10:05:23 2004 for RSBAC by doxygen 1.3.8