dazukoio_core.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "dazukoio.h"
#include "dazukoio_core.h"
#include "dazuko_transport.h"
#include "dazuko_version.h"
#include "dazukoio_linux_compat1.h"

Go to the source code of this file.

Defines
#define	DAZUKO_FILENAME_MAX_LENGTH   6144
#define	DAZUKO_SET_VERSION(maj, min, rev, rel, txt)
#define	DAZUKO_POP_NUMBER(num)
Functions
static char	char_to_hex (char c)
static void	unescape_string (char *string)
int	dazuko_get_value (const char *key, const char *string, char *buffer, size_t buffer_size)
static struct dazuko_request *	alloc_request (int type, int request_length, int response_length)
static void	free_request (struct dazuko_request **request_ref)
int	dazukoVersion (struct dazuko_version *version)
int	dazukoIOVersion (struct dazuko_version *version)
int	dazukoRegister (const char *groupName, const char *mode)
static int	process_request (struct dazuko_id *id, char *buffer, size_t buffer_size, struct dazuko_request *request, int reply_required)
static void	dazuko_set_version (const char *reply_buffer)
static int	dazukoRegister_TS_inner (dazuko_id_t **dazuko_id, const char *groupName, const char *mode)
int	dazukoRegister_TS (dazuko_id_t **dazuko_id, const char *groupName, const char *mode)
int	dazukoSetAccessMask (unsigned long accessMask)
int	dazukoSetAccessMask_TS (dazuko_id_t *dazuko_id, unsigned long accessMask)
static int	dazuko_set_path (dazuko_id_t *dazuko_id, const char *path, int type)
int	dazukoAddIncludePath (const char *path)
int	dazukoAddIncludePath_TS (dazuko_id_t *dazuko_id, const char *path)
int	dazukoAddExcludePath (const char *path)
int	dazukoAddExcludePath_TS (dazuko_id_t *dazuko_id, const char *path)
int	dazukoRemoveAllPaths (void)
int	dazukoRemoveAllPaths_TS (dazuko_id_t *dazuko_id)
int	dazukoGetAccess (struct dazuko_access **acc)
int	dazukoGetAccess_TS (dazuko_id_t *dazuko_id, struct dazuko_access **acc)
int	dazukoReturnAccess (struct dazuko_access **acc)
int	dazukoReturnAccess_TS (dazuko_id_t *dazuko_id, struct dazuko_access **acc)
int	dazukoUnregister (void)
int	dazukoUnregister_TS (dazuko_id_t **dazuko_id)
int	dazukoInitializeCache (struct dazuko_cache_settings *cs)
int	dazukoInitializeCache_TS (dazuko_id_t *dazuko_id, struct dazuko_cache_settings *cs)
int	dazukoRemoveAllTrusted (void)
int	dazukoRemoveAllTrusted_TS (dazuko_id_t *dazuko_id)
int	dazukoRemoveTrusted (const char *token)
int	dazukoRemoveTrusted_TS (dazuko_id_t *dazuko_id, const char *token)
Variables
const char *	DAZUKO_VERSION_STAMP = "\nDazukoVersion=" DAZUKO_VERSION_MAJOR "." DAZUKO_VERSION_MINOR "." DAZUKO_VERSION_REVISION "." DAZUKO_VERSION_RELEASE "\n"
const char *	VERSION_STRING
dazuko_id_t *	_GLOBAL_DAZUKO = NULL
static int	_GLOBAL_DAZUKO_COMPAT1 = 0
static int	_GLOBAL_WITH_REQSTREAM = 0
static int	_GLOBAL_WITH_DEVWRITE = 0
static int	_SET_DAZUKO_VERSION = 0
static struct dazuko_version	_DAZUKO_VERSION

---

Define Documentation

#define DAZUKO_FILENAME_MAX_LENGTH   6144

Definition at line 59 of file dazukoio_core.c. Referenced by dazukoGetAccess_TS().

#define DAZUKO_POP_NUMBER (  num   )

Value: { \ if (p1 == NULL) \ { \ error = 1; \ } \ else \ { \ p2 = strchr(p1, '.'); \ if (p2 != NULL) \ { \ *p2 = 0; \ p2++; \ } \ num = atoi(p1); \ p1 = p2; \ } \ } Referenced by dazuko_set_version().

#define DAZUKO_SET_VERSION (  maj, min, rev, rel, txt   )

Value: { \ if (!_SET_DAZUKO_VERSION) \ { \ _DAZUKO_VERSION.major = maj; \ _DAZUKO_VERSION.minor = min; \ _DAZUKO_VERSION.revision = rev; \ _DAZUKO_VERSION.release = rel; \ snprintf(_DAZUKO_VERSION.text, sizeof(_DAZUKO_VERSION.text), txt); \ _DAZUKO_VERSION.text[sizeof(_DAZUKO_VERSION.text) - 1] = 0; \ _SET_DAZUKO_VERSION = 1; \ } \ } Definition at line 318 of file dazukoio_core.c. Referenced by dazuko_set_version(), and dazukoRegister_TS_inner().

---

Function Documentation

static struct dazuko_request* alloc_request (  int  type, int  request_length, int  response_length )  [static]

Definition at line 158 of file dazukoio_core.c. References NULL. Referenced by dazuko_set_path(), dazukoGetAccess_TS(), dazukoInitializeCache_TS(), dazukoRegister_TS_inner(), dazukoRemoveAllPaths_TS(), dazukoRemoveAllTrusted_TS(), dazukoRemoveTrusted_TS(), dazukoReturnAccess_TS(), dazukoSetAccessMask_TS(), and dazukoUnregister_TS(). { struct dazuko_request *request; char *s; request = (struct dazuko_request *)malloc(sizeof(struct dazuko_request)); if (request == NULL) return NULL; memset(request, 0, sizeof(struct dazuko_request)); request->type[0] = (char)type; s = (char *)malloc(request_length); if (s == NULL) { free(request); return NULL; } memset(s, 0, request_length); request->buffer = s; /* Note: buffer and buffer_size should be set after * calling this function */ if (response_length > 0) { s = (char *)malloc(response_length); if (s == NULL) { free(request->buffer); free(request); return NULL; } memset(s, 0, response_length); request->reply_buffer = s; request->reply_buffer_size = response_length; } return request; }

static char char_to_hex (  char  c  )  [inline, static]

Definition at line 74 of file dazukoio_core.c. Referenced by unescape_string(). { /* ugly, but fast */ switch (c) { case '1': return 1; case '2': return 2; case '3': return 3; case '4': return 4; case '5': return 5; case '6': return 6; case '7': return 7; case '8': return 8; case '9': return 9; case 'a': case 'A': return 10; case 'b': case 'B': return 11; case 'c': case 'C': return 12; case 'd': case 'D': return 13; case 'e': case 'E': return 14; case 'f': case 'F': return 15; } return 0; }

int dazuko_get_value (  const char *  key, const char *  string, char *  buffer, size_t  buffer_size )

Definition at line 124 of file dazukoio_core.c. References NULL. { const char *p1; const char *p2; size_t size; if (buffer == NULL || buffer_size < 1) return -1; buffer[0] = 0; if (key == NULL || string == NULL) return -1; p1 = strstr(string, key); if (p1 == NULL) return -1; p1 += strlen(key); for (p2=p1 ; *p2 && *p2!='\n' ; p2++) continue; size = p2 - p1; if (size >= buffer_size) size = buffer_size - 1; memcpy(buffer, p1, size); buffer[size] = 0; return 0; }

static int dazuko_set_path (  dazuko_id_t *  dazuko_id, const char *  path, int  type )  [static]

Definition at line 644 of file dazukoio_core.c. References alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, free_request(), dazuko_id::id, ITOA_SIZE, NULL, process_request(), and xp_verify_id(). Referenced by dazukoAddExcludePath_TS(), and dazukoAddIncludePath_TS(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; if (dazuko_id == NULL) return -1; if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; if (path == NULL) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 + 2 + 1 + strlen(path) /* \nPT=path */ + 1 /* \0 */ ; request = alloc_request(type, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d\nPT=%s", dazuko_id->id, path); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { free_request(&request); return -1; } free_request(&request); return 0; }

static void dazuko_set_version (  const char *  reply_buffer  )  [static]

Definition at line 332 of file dazukoio_core.c. References dazuko_get_value(), DAZUKO_POP_NUMBER, DAZUKO_SET_VERSION, and ITOA_SIZE. Referenced by dazukoRegister_TS_inner(). { char vn_buffer[ITOA_SIZE + DAZUKO_VERSION_TEXT_SIZE]; char vs_buffer[ITOA_SIZE + DAZUKO_VERSION_TEXT_SIZE]; int maj = 0; int min = 0; int rev = 0; int rel = 0; char *p1; char *p2; int error = 0; #define DAZUKO_POP_NUMBER(num) \ { \ if (p1 == NULL) \ { \ error = 1; \ } \ else \ { \ p2 = strchr(p1, '.'); \ if (p2 != NULL) \ { \ *p2 = 0; \ p2++; \ } \ num = atoi(p1); \ p1 = p2; \ } \ } if (dazuko_get_value("\nVN=", reply_buffer, vn_buffer, sizeof(vn_buffer)) != 0) { error = 1; } if (!error && dazuko_get_value("\nVS=", reply_buffer, vs_buffer, sizeof(vs_buffer)) != 0) { error = 1; } if (!error) { p1 = vn_buffer; DAZUKO_POP_NUMBER(maj); DAZUKO_POP_NUMBER(min); DAZUKO_POP_NUMBER(rev); DAZUKO_POP_NUMBER(rel); } if (error) { /* this should never occur unless someone used a CVS snapshot */ DAZUKO_SET_VERSION(2, 1, 0, 0, "2.1.0-prex"); } else { DAZUKO_SET_VERSION(maj, min, rev, rel, vs_buffer); } }

int dazukoAddExcludePath (  const char *  path  )

Definition at line 701 of file dazukoio_core.c. References dazukoAddExcludePath_TS(). { return dazukoAddExcludePath_TS(_GLOBAL_DAZUKO, path); }

int dazukoAddExcludePath_TS (  dazuko_id_t *  dazuko_id, const char *  path )

Definition at line 706 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, ADD_EXCLUDE_PATH, dazuko_set_path(), and dazukoAddExcludePath_TS_compat1(). Referenced by dazukoAddExcludePath(). { #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return dazukoAddExcludePath_TS_compat1(dazuko_id, path); #endif return dazuko_set_path(dazuko_id, path, ADD_EXCLUDE_PATH); }

int dazukoAddIncludePath (  const char *  path  )

Definition at line 686 of file dazukoio_core.c. References dazukoAddIncludePath_TS(). { return dazukoAddIncludePath_TS(_GLOBAL_DAZUKO, path); }

int dazukoAddIncludePath_TS (  dazuko_id_t *  dazuko_id, const char *  path )

Definition at line 691 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, ADD_INCLUDE_PATH, dazuko_set_path(), and dazukoAddIncludePath_TS_compat1(). Referenced by dazukoAddIncludePath(). { #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return dazukoAddIncludePath_TS_compat1(dazuko_id, path); #endif return dazuko_set_path(dazuko_id, path, ADD_INCLUDE_PATH); }

int dazukoGetAccess (  struct dazuko_access **  acc  )

Definition at line 764 of file dazukoio_core.c. References dazukoGetAccess_TS(). { return dazukoGetAccess_TS(_GLOBAL_DAZUKO, acc); }

int dazukoGetAccess_TS (  dazuko_id_t *  dazuko_id, struct dazuko_access **  acc )

Definition at line 769 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, DAZUKO_FILENAME_MAX_LENGTH, dazuko_get_value(), dazukoGetAccess_TS_compat1_wrapper(), dazukoReturnAccess_TS_compat1_wrapper(), dazuko_access::event, dazuko_access::file_device, dazuko_access::file_gid, dazuko_access::file_mode, dazuko_access::file_size, dazuko_access::file_uid, dazuko_access::filename, dazuko_access::flags, free_request(), GET_AN_ACCESS, dazuko_id::id, ITOA_SIZE, dazuko_access::mode, NULL, dazuko_access::pid, process_request(), dazuko_request::reply_buffer, dazuko_request::reply_buffer_size_used, dazuko_access::set_event, dazuko_access::set_file_device, dazuko_access::set_file_gid, dazuko_access::set_file_mode, dazuko_access::set_file_size, dazuko_access::set_file_uid, dazuko_access::set_filename, dazuko_access::set_flags, dazuko_access::set_mode, dazuko_access::set_pid, dazuko_access::set_uid, dazuko_access::uid, unescape_string(), and xp_verify_id(). Referenced by dazukoGetAccess(). { struct dazuko_request *request; struct dazuko_access *temp_acc; size_t size; size_t filename_size; char buffer[ITOA_SIZE]; #if !defined(NO_COMPAT1) int compat1_ret; #endif if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) { compat1_ret = dazukoGetAccess_TS_compat1_wrapper(dazuko_id, acc); if (compat1_ret == 0 && !(dazuko_id->write_mode)) { /* we are in read_only mode so we return the access immediately */ dazukoReturnAccess_TS_compat1_wrapper(dazuko_id, acc, 1, 0); /* this could be dangerous, we do not check if the return was successfull! */ } return compat1_ret; } #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; if (acc == NULL) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 /* \0 */ ; request = alloc_request(GET_AN_ACCESS, size, 1 + 2 + 1 + DAZUKO_FILENAME_MAX_LENGTH /* \nFN=filename */ + 1024 /* miscellaneous access attributes */ + 1 /* \0 */ ); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d", dazuko_id->id); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; temp_acc = (struct dazuko_access *)malloc(sizeof(struct dazuko_access)); if (temp_acc == NULL) { free_request(&request); return -1; } memset(temp_acc, 0, sizeof(struct dazuko_access)); filename_size = DAZUKO_FILENAME_MAX_LENGTH + 1; temp_acc->filename = (char *)malloc(filename_size); if (temp_acc->filename == NULL) { free(temp_acc); free_request(&request); return -1; } if (process_request(dazuko_id, buffer, sizeof(buffer), request, 1) != 0) { free(temp_acc->filename); free(temp_acc); free_request(&request); return -1; } if (request->reply_buffer_size_used > 0) { if (dazuko_get_value("\nFN=", request->reply_buffer, temp_acc->filename, filename_size) == 0) { temp_acc->set_filename = 1; unescape_string(temp_acc->filename); } if (dazuko_get_value("\nEV=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->event = atoi(buffer); temp_acc->set_event = 1; } if (dazuko_get_value("\nFL=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->flags = atoi(buffer); temp_acc->set_flags = 1; } if (dazuko_get_value("\nMD=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->mode = atoi(buffer); temp_acc->set_mode = 1; } if (dazuko_get_value("\nUI=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->uid = atoi(buffer); temp_acc->set_uid = 1; } if (dazuko_get_value("\nPI=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->pid = atoi(buffer); temp_acc->set_pid = 1; } if (dazuko_get_value("\nFS=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->file_size = atol(buffer); temp_acc->set_file_size = 1; } if (dazuko_get_value("\nFU=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->file_uid = atoi(buffer); temp_acc->set_file_uid = 1; } if (dazuko_get_value("\nFG=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->file_gid = atoi(buffer); temp_acc->set_file_gid = 1; } if (dazuko_get_value("\nDT=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->file_device = atoi(buffer); temp_acc->set_file_device = 1; } if (dazuko_get_value("\nFM=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { temp_acc->file_mode = atoi(buffer); temp_acc->set_file_mode = 1; } } free_request(&request); *acc = temp_acc; return 0; }

int dazukoInitializeCache (  struct dazuko_cache_settings *  cs  )

Definition at line 1051 of file dazukoio_core.c. References dazukoInitializeCache_TS(). { return dazukoInitializeCache_TS(_GLOBAL_DAZUKO, cs); }

int dazukoInitializeCache_TS (  dazuko_id_t *  dazuko_id, struct dazuko_cache_settings *  cs )

Definition at line 1056 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, dazuko_get_value(), free_request(), dazuko_id::id, INITIALIZE_CACHE, ITOA_SIZE, NULL, process_request(), dazuko_request::reply_buffer, dazuko_request::reply_buffer_size_used, and xp_verify_id(). Referenced by dazukoInitializeCache(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; int cache_available = 0; if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return -1; #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; if (cs == NULL) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 + 2 + 1 + ITOA_SIZE /* \nCT=cachettl */ + 1 /* \0 */ ; request = alloc_request(INITIALIZE_CACHE, size, 1 + 2 + 1 + ITOA_SIZE /* \nCA=cacheavailable */ + 1024 /* miscellaneous cache attributes */ + 1 /* \0 */ ); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d\nCT=%lu", dazuko_id->id, cs->ttl); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 1) != 0) { free_request(&request); return -1; } if (request->reply_buffer_size_used > 0) { if (dazuko_get_value("\nCA=", request->reply_buffer, buffer, sizeof(buffer)) == 0) { cache_available = atoi(buffer); } } free_request(&request); if (cache_available) return 0; return -1; }

int dazukoIOVersion (  struct dazuko_version *  version  )

Definition at line 240 of file dazukoio_core.c. References DAZUKO_VERSION_MAJOR, DAZUKO_VERSION_MINOR, DAZUKO_VERSION_RELEASE, DAZUKO_VERSION_REVISION, NULL, and VERSION_STRING. { if (version == NULL) return -1; memset(version, 0, sizeof(struct dazuko_version)); version->major = atoi(DAZUKO_VERSION_MAJOR); version->minor = atoi(DAZUKO_VERSION_MINOR); version->revision = atoi(DAZUKO_VERSION_REVISION); version->release = atoi(DAZUKO_VERSION_RELEASE); snprintf(version->text, sizeof(version->text), "%s", VERSION_STRING); version->text[sizeof(version->text) - 1] = 0; return 0; }

int dazukoRegister (  const char *  groupName, const char *  mode )

Definition at line 258 of file dazukoio_core.c. References dazukoRegister_TS(). { return dazukoRegister_TS(&_GLOBAL_DAZUKO, groupName, mode); }

int dazukoRegister_TS (  dazuko_id_t **  dazuko_id, const char *  groupName, const char *  mode )

Definition at line 546 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, _GLOBAL_WITH_DEVWRITE, _GLOBAL_WITH_REQSTREAM, and dazukoRegister_TS_inner(). Referenced by dazukoRegister(). { int rc; /* prep: enable highest available mode */ _GLOBAL_WITH_REQSTREAM = 1; _GLOBAL_WITH_DEVWRITE = 0; #if !defined(NO_COMPAT1) _GLOBAL_DAZUKO_COMPAT1 = 0; #endif /* try to register until success or methods are exhausted */ while (1) { /* stop if we succeeded to register */ rc = dazukoRegister_TS_inner(dazuko_id, groupName, mode); if (rc == 0) break; /* try to fallback if possible */ if (_GLOBAL_WITH_REQSTREAM) { /* the "ra=" method failed, fallback to "RA=" */ _GLOBAL_WITH_REQSTREAM = 0; _GLOBAL_WITH_DEVWRITE = 1; continue; } #if !defined(NO_COMPAT1) if (_GLOBAL_WITH_DEVWRITE) { /* the "RA=" method failed, fallback to compat1 */ _GLOBAL_WITH_DEVWRITE = 0; _GLOBAL_DAZUKO_COMPAT1 = 1; continue; } #endif /* we ran out of alternatives, return with an error */ break; } return rc; }

static int dazukoRegister_TS_inner (  dazuko_id_t **  dazuko_id, const char *  groupName, const char *  mode )  [static]

Definition at line 398 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, _GLOBAL_WITH_DEVWRITE, _GLOBAL_WITH_REQSTREAM, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, dazuko_get_value(), dazuko_set_version(), DAZUKO_SET_VERSION, dazukoRegister_TS_compat1_wrapper(), free_request(), ITOA_SIZE, NULL, process_request(), REGISTER, dazuko_request::reply_buffer, xp_connection_close(), and xp_connection_open(). Referenced by dazukoRegister_TS(). { struct dazuko_request *request; char buffer[ITOA_SIZE]; char regMode[3]; dazuko_id_t *temp_id; size_t size; int write_mode = 0; #if !defined(NO_COMPAT1) int compat1_ret; #endif if (dazuko_id == NULL) return -1; /* set default group name if one was not given */ if (groupName == NULL) groupName = "_GENERIC"; /* set default mode if one was not given */ if (mode == NULL) mode = "r"; if (strcasecmp(mode, "r") == 0) { strncpy(regMode, "R", sizeof(regMode)); write_mode = 0; } else if (strcasecmp(mode, "r+") == 0 || strcasecmp(mode, "rw") == 0) { strncpy(regMode, "RW", sizeof(regMode)); write_mode = 1; } else { return -1; } regMode[sizeof(regMode) - 1] = 0; #if !defined(NO_COMPAT1) /* shortcut for the compat12 layer */ if (_GLOBAL_DAZUKO_COMPAT1) { compat1_ret = dazukoRegister_TS_compat1_wrapper(dazuko_id, groupName); if (compat1_ret == 0) { (*dazuko_id)->write_mode = write_mode; DAZUKO_SET_VERSION(1, 0, 0, 0, "1.x"); } return compat1_ret; } /* fallthrough to the device writing path */ #endif /* create temporary id */ temp_id = (dazuko_id_t *)malloc(sizeof(dazuko_id_t)); if (temp_id == NULL) return -1; memset(temp_id, 0, sizeof(dazuko_id_t)); /* open device */ if (xp_connection_open(temp_id) != 0) { free(temp_id); return -1; } /* allocate a request, fill in "RM=" and "GN=" */ size = 1 + 2 + 1 + strlen(regMode) /* \nRM=mode */ + 1 + 2 + 1 + strlen(groupName) /* \nGN=groupName */ + 1 /* \0 */ ; request = alloc_request(REGISTER, size, 4096); if (request == NULL) { xp_connection_close(temp_id); free(temp_id); return -1; } snprintf(request->buffer, size, "\nRM=%s\nGN=%s", regMode, groupName); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(temp_id, buffer, sizeof(buffer), request, 1) != 0) { xp_connection_close(temp_id); free(temp_id); free_request(&request); return -1; } if (dazuko_get_value("\nID=", request->reply_buffer, buffer, sizeof(buffer)) != 0) { xp_connection_close(temp_id); free(temp_id); free_request(&request); return -1; } temp_id->id = atoi(buffer); if (temp_id->id < 0) { xp_connection_close(temp_id); free(temp_id); free_request(&request); return -1; } temp_id->write_mode = write_mode; if (_GLOBAL_WITH_REQSTREAM) { dazuko_set_version(request->reply_buffer); } else if (_GLOBAL_WITH_DEVWRITE) { DAZUKO_SET_VERSION(2, 0, 0, 0, "2.0.x"); } free_request(&request); *dazuko_id = temp_id; return 0; }

int dazukoRemoveAllPaths (  void   )

Definition at line 716 of file dazukoio_core.c. References dazukoRemoveAllPaths_TS(). { return dazukoRemoveAllPaths_TS(_GLOBAL_DAZUKO); }

int dazukoRemoveAllPaths_TS (  dazuko_id_t *  dazuko_id  )

Definition at line 721 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, dazukoRemoveAllPaths_TS_compat1(), free_request(), ITOA_SIZE, NULL, process_request(), REMOVE_ALL_PATHS, and xp_verify_id(). Referenced by dazukoRemoveAllPaths(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return dazukoRemoveAllPaths_TS_compat1(dazuko_id); #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 /* \0 */ ; request = alloc_request(REMOVE_ALL_PATHS, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d", dazuko_id->id); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { free_request(&request); return -1; } free_request(&request); return 0; }

int dazukoRemoveAllTrusted (  void   )

Definition at line 1119 of file dazukoio_core.c. References dazukoRemoveAllTrusted_TS(). { return dazukoRemoveAllTrusted_TS(_GLOBAL_DAZUKO); }

int dazukoRemoveAllTrusted_TS (  dazuko_id_t *  dazuko_id  )

Definition at line 1124 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, free_request(), dazuko_id::id, ITOA_SIZE, NULL, process_request(), REMOVE_ALL_TRUSTED, and xp_verify_id(). Referenced by dazukoRemoveAllTrusted(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return -1; #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 /* \0 */ ; request = alloc_request(REMOVE_ALL_TRUSTED, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d", dazuko_id->id); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { free_request(&request); return -1; } free_request(&request); return 0; }

int dazukoRemoveTrusted (  const char *  token  )

Definition at line 1167 of file dazukoio_core.c. References dazukoRemoveTrusted_TS(). { return dazukoRemoveTrusted_TS(_GLOBAL_DAZUKO, token); }

int dazukoRemoveTrusted_TS (  dazuko_id_t *  dazuko_id, const char *  token )

Definition at line 1172 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, free_request(), dazuko_id::id, ITOA_SIZE, NULL, process_request(), REMOVE_TRUSTED, and xp_verify_id(). Referenced by dazukoRemoveTrusted(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; if (dazuko_id == NULL || token == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return -1; #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 + 2 + 1 + strlen(token) /* \nTT=token */ + 1 /* \0 */ ; request = alloc_request(REMOVE_TRUSTED, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d\nTT=%s", dazuko_id->id, token); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { free_request(&request); return -1; } free_request(&request); return 0; }

int dazukoReturnAccess (  struct dazuko_access **  acc  )

Definition at line 928 of file dazukoio_core.c. References dazukoReturnAccess_TS(). { return dazukoReturnAccess_TS(_GLOBAL_DAZUKO, acc); }

int dazukoReturnAccess_TS (  dazuko_id_t *  dazuko_id, struct dazuko_access **  acc )

Definition at line 933 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, dazukoReturnAccess_TS_compat1_wrapper(), free_request(), ITOA_SIZE, NULL, process_request(), RETURN_AN_ACCESS, and xp_verify_id(). Referenced by dazukoReturnAccess(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return dazukoReturnAccess_TS_compat1_wrapper(dazuko_id, acc, dazuko_id->write_mode, 1); #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; if (acc == NULL) return -1; if (*acc == NULL) return -1; if (dazuko_id->write_mode) { size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 + 2 + 1 + ITOA_SIZE /* \nDN=deny */ + 1 /* \0 */ ; request = alloc_request(RETURN_AN_ACCESS, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d\nDN=%d", dazuko_id->id, (*acc)->deny == 0 ? 0 : 1); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { /* there could be big problems if this happens */ if ((*acc)->filename != NULL) free((*acc)->filename); free(*acc); *acc = NULL; free_request(&request); return -1; } free_request(&request); } if ((*acc)->filename != NULL) free((*acc)->filename); free(*acc); *acc = NULL; return 0; }

int dazukoSetAccessMask (  unsigned long  accessMask  )

Definition at line 595 of file dazukoio_core.c. References dazukoSetAccessMask_TS(). { return dazukoSetAccessMask_TS(_GLOBAL_DAZUKO, accessMask); }

int dazukoSetAccessMask_TS (  dazuko_id_t *  dazuko_id, unsigned long  accessMask )

Definition at line 600 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, dazukoSetAccessMask_TS_compat1(), free_request(), ITOA_SIZE, NULL, process_request(), SET_ACCESS_MASK, and xp_verify_id(). Referenced by dazukoSetAccessMask(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return dazukoSetAccessMask_TS_compat1(dazuko_id, accessMask); #endif if (dazuko_id->id < 0) return -1; if (xp_verify_id(dazuko_id) != 0) return -1; size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 + 2 + 1 + ITOA_SIZE /* \nAM=accessMask */ + 1 /* \0 */ ; request = alloc_request(SET_ACCESS_MASK, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d\nAM=%lu", dazuko_id->id, accessMask); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { free_request(&request); return -1; } free_request(&request); return 0; }

int dazukoUnregister (  void   )

Definition at line 997 of file dazukoio_core.c. References dazukoUnregister_TS(). { return dazukoUnregister_TS(&_GLOBAL_DAZUKO); }

int dazukoUnregister_TS (  dazuko_id_t **  dazuko_id  )

Definition at line 1002 of file dazukoio_core.c. References _GLOBAL_DAZUKO_COMPAT1, alloc_request(), dazuko_request::buffer, dazuko_request::buffer_size, dazukoUnregister_TS_compat1_wrapper(), free_request(), ITOA_SIZE, NULL, process_request(), UNREGISTER, xp_connection_close(), and xp_verify_id(). Referenced by dazukoUnregister(). { struct dazuko_request *request; size_t size; char buffer[ITOA_SIZE]; int error = 0; if (dazuko_id == NULL) return -1; #if !defined(NO_COMPAT1) if (_GLOBAL_DAZUKO_COMPAT1) return dazukoUnregister_TS_compat1_wrapper(dazuko_id); #endif if (*dazuko_id == NULL) return -1; if (xp_verify_id(*dazuko_id) == 0) { size = 1 + 2 + 1 + ITOA_SIZE /* \nID=id */ + 1 /* \0 */ ; request = alloc_request(UNREGISTER, size, 0); if (request == NULL) return -1; snprintf(request->buffer, size, "\nID=%d", (*dazuko_id)->id); request->buffer[size - 1] = 0; request->buffer_size = strlen(request->buffer) + 1; if (process_request(*dazuko_id, buffer, sizeof(buffer), request, 0) != 0) { /* there could be big problems if this happens */ error = -1; } free_request(&request); } xp_connection_close(*dazuko_id); free(*dazuko_id); *dazuko_id = NULL; return error; }

int dazukoVersion (  struct dazuko_version *  version  )

Definition at line 227 of file dazukoio_core.c. References _DAZUKO_VERSION, _SET_DAZUKO_VERSION, and NULL. { if (version == NULL) return -1; if (!_SET_DAZUKO_VERSION) return -1; memcpy(version, &_DAZUKO_VERSION, sizeof(struct dazuko_version)); return 0; }

static void free_request (  struct dazuko_request **  request_ref  )  [static]

Definition at line 204 of file dazukoio_core.c. References dazuko_request::buffer, NULL, and dazuko_request::reply_buffer. Referenced by dazuko_set_path(), dazukoGetAccess_TS(), dazukoInitializeCache_TS(), dazukoRegister_TS_inner(), dazukoRemoveAllPaths_TS(), dazukoRemoveAllTrusted_TS(), dazukoRemoveTrusted_TS(), dazukoReturnAccess_TS(), dazukoSetAccessMask_TS(), and dazukoUnregister_TS(). { struct dazuko_request *request; if (request_ref == NULL) return; request = *request_ref; if (request == NULL) return; if (request->buffer != NULL) free(request->buffer); if (request->reply_buffer != NULL) free(request->reply_buffer); free(request); *request_ref = NULL; }

static int process_request (  struct dazuko_id *  id, char *  buffer, size_t  buffer_size, struct dazuko_request *  request, int  reply_required )  [static]

Definition at line 263 of file dazukoio_core.c. References _GLOBAL_WITH_DEVWRITE, _GLOBAL_WITH_REQSTREAM, dazuko_reqstream_dim_chunk0(), dazuko_reqstream_hl2ll(), dazuko_reqstream_ll2hl(), NULL, and xp_process_request(). Referenced by dazuko_set_path(), dazukoGetAccess_TS(), dazukoInitializeCache_TS(), dazukoRegister_TS_inner(), dazukoRemoveAllPaths_TS(), dazukoRemoveAllTrusted_TS(), dazukoRemoveTrusted_TS(), dazukoReturnAccess_TS(), dazukoSetAccessMask_TS(), and dazukoUnregister_TS(). { unsigned char *llreq = NULL; int error = 0; size_t size; if (_GLOBAL_WITH_REQSTREAM) { /* we add an extra 4 bytes as "size of chunk 1" */ size = dazuko_reqstream_dim_chunk0(sizeof(char), sizeof(int), sizeof(void *)) + 4; llreq = (unsigned char *)malloc(size); if (llreq == NULL) return -1; /* this is especially important for the last 4 bytes */ memset(llreq, 0, size); if (dazuko_reqstream_hl2ll(request, llreq) != 0) { free(llreq); return -1; } snprintf(buffer, buffer_size, "\nra=%lu", (unsigned long)llreq); } else if (_GLOBAL_WITH_DEVWRITE) { snprintf(buffer, buffer_size, "\nRA=%lu", (unsigned long)request); } else { /* why are we here? */ return -1; } buffer[buffer_size - 1] = 0; error = xp_process_request(id, buffer, strlen(buffer) + 1); if (reply_required && !error && _GLOBAL_WITH_REQSTREAM) { if (dazuko_reqstream_ll2hl(llreq, request, 1) != 0) { /* this could be dangerous if it happens */ error = -1; } } if (llreq != NULL) free(llreq); return error; }

static void unescape_string (  char *  string  )  [static]

Definition at line 100 of file dazukoio_core.c. References char_to_hex(). Referenced by dazukoGetAccess_TS(). { char *p; for (p=string ; *p ; p++) { /* check if we have \x */ if ((*p == '\\') && (*(p+1) == 'x')) { /* this is not cheap, but it should not occur often */ /* check if we have two more values following \x */ if (*(p+2) && *(p+3)) { *p = char_to_hex(*(p+2)); *p <<= 4; *p |= char_to_hex(*(p+3)); memmove(p + 1, p + 4, strlen(p+4) + 1); } } } }

---

Variable Documentation

struct dazuko_version _DAZUKO_VERSION [static]

Definition at line 71 of file dazukoio_core.c. Referenced by dazukoVersion().

dazuko_id_t* _GLOBAL_DAZUKO = NULL

Definition at line 61 of file dazukoio_core.c.

int _GLOBAL_DAZUKO_COMPAT1 = 0 [static]

Definition at line 64 of file dazukoio_core.c. Referenced by dazukoAddExcludePath_TS(), dazukoAddIncludePath_TS(), dazukoGetAccess_TS(), dazukoInitializeCache_TS(), dazukoRegister_TS(), dazukoRegister_TS_inner(), dazukoRemoveAllPaths_TS(), dazukoRemoveAllTrusted_TS(), dazukoRemoveTrusted_TS(), dazukoReturnAccess_TS(), dazukoSetAccessMask_TS(), and dazukoUnregister_TS().

int _GLOBAL_WITH_DEVWRITE = 0 [static]

Definition at line 68 of file dazukoio_core.c. Referenced by dazukoRegister_TS(), dazukoRegister_TS_inner(), and process_request().

int _GLOBAL_WITH_REQSTREAM = 0 [static]

Definition at line 67 of file dazukoio_core.c. Referenced by dazukoRegister_TS(), dazukoRegister_TS_inner(), and process_request().

int _SET_DAZUKO_VERSION = 0 [static]

Definition at line 70 of file dazukoio_core.c. Referenced by dazukoVersion().

const char* DAZUKO_VERSION_STAMP = "\nDazukoVersion=" DAZUKO_VERSION_MAJOR "." DAZUKO_VERSION_MINOR "." DAZUKO_VERSION_REVISION "." DAZUKO_VERSION_RELEASE "\n"

Definition at line 48 of file dazukoio_core.c.

const char* VERSION_STRING

Initial value: DAZUKO_VERSION_MAJOR "." DAZUKO_VERSION_MINOR "." DAZUKO_VERSION_REVISION "-pre" DAZUKO_VERSION_RELEASE Definition at line 51 of file dazukoio_core.c.

---