void parse(scene** now) {
evalparser e;
e.nxt = malloc(sizeof(char) * (strlen((*now)->nxt)+1));
e.nxt[0] = 0;
choiceparser p;
p_init(&p, *now);
p.eval = &e;
char* s = (*now)->nxt;
if (eval(&s, &e)) {
p.choose = &e_defchoose;
}
while(*s) {
p.examine(s, &p);
s++;
}
say(p.txt);
p.dischoice(&p);
while( p.choose(&p, pause(*now, &s_quit)) )
;
(*now)->flag++;
free0(e.nxt);
free0(p.txt);
freeall(p.choice);
}
/*
** ytcp_server_delete()
** Delete a yTCP server and all its threads.
*/
ytcp_server_t *ytcp_server_delete(ytcp_server_t *server,
unsigned short wait_threads)
{
ytcp_thread_t *thread;
YLOG_MOD("ytcp", YLOG_DEBUG, "Entering");
if (!server || !server->vect_threads)
{
YLOG_ADD(YLOG_NOTE, "Server doesn't exist.");
return (NULL);
}
while ((thread = (ytcp_thread_t*)yv_get(server->vect_threads)))
{
if (wait_threads && thread->state == YTCP_RUN)
{
while (thread->state == YTCP_RUN)
usleep(500);
}
thread->state = YTCP_CLOSE;
pthread_mutex_unlock(&(thread->mut_do));
pthread_join(thread->tid, NULL);
pthread_mutex_destroy(&(thread->mut_do));
free0(thread);
server->nbr_threads--;
}
yv_del(&(server->vect_threads), NULL, NULL);
free0(server);
YLOG_MOD("ytcp", YLOG_DEBUG, "Exiting");
return (NULL);
}
/*
** _ydom_inside_hdlr()
** DOM handler for SAX parsing
*/
static void _ydom_inside_hdlr(ysax_t *sax, char *str)
{
ydom_t *dom;
ydom_node_t *text;
char *tmp;
YLOG_MOD("ydom", YLOG_DEBUG, "Entering");
dom = (ydom_t*)YSAX_DATA(sax);
if (dom->current_parsed_node->node_type == TEXT_NODE)
{
tmp = malloc0(strlen(dom->current_parsed_node->value) + strlen(str) + 1);
strcpy(tmp, dom->current_parsed_node->value);
strcat(tmp, str);
free0(str);
free0(dom->current_parsed_node->value);
dom->current_parsed_node->value = tmp;
}
else
{
if (!(text = malloc0(sizeof(ydom_node_t))))
{
YLOG_ADD(YLOG_ERR, "Unable to allocate memory");
return ;
}
text->node_type = TEXT_NODE;
text->value = str;
text->line_nbr = sax->line_nbr;
_ydom_add_child_to_node(dom->current_parsed_node, text);
dom->current_parsed_node = text;
}
YLOG_MOD("ydom", YLOG_DEBUG, "Exiting");
}
long CheckIfUserHasRole( char *roleName,
char *userId)
{
char *tmp = NULL;
char *roleId = NULL;
/************************/
/* walidacja parametrow */
/************************/
if (roleName==NULL) { BMD_FOK(BMD_ERR_PARAM1); }
if (userId==NULL) { BMD_FOK(BMD_ERR_PARAM2); }
asprintf(&tmp, "%s|%s", userId, roleName);
if (tmp==NULL) { BMD_FOK(NO_MEMORY); }
//SELECT users_and_roles.fk_users, users_and_roles.default_role, roles.id, roles.name, users_and_roles.fk_users||roles.name FROM roles LEFT JOIN users_and_roles ON (users_and_roles.fk_roles=roles.id);
BMD_FOK_CHG(getElementWithCondition( _GLOBAL_UserRolesDictionary, 4, tmp, 2, &roleId), LIBBMDSQL_ROLE_NOT_REGISTERED_IN_SYSTEM);
if (roleId==NULL) { return LIBBMDSQL_ROLE_NOT_REGISTERED_IN_SYSTEM; }
/************/
/* porzadki */
/************/
free0(roleId);
free0(tmp);
return BMD_OK;
}
/*
** free_deck()
** Free the memory allocated for a deck.
*/
void free_deck(void *deck, void *data)
{
cg_deck_t *d = deck;
if (!deck)
return ;
free0(d->ditch_odd);
free0(d->ditch_even);
free0(d);
}
/*
** import_font()
** Try to import a given font.
*/
void import_font(cg_t *carta, ydom_node_t *node)
{
struct stat st;
cg_font_t *font;
if (!(font = malloc0(sizeof(cg_font_t))))
return ;
font->id = ydom_node_get_attr_value(node, "id");
font->outline = ydom_node_get_attr_value(node, "outline");
font->metrics = ydom_node_get_attr_value(node, "metrics");
if (!font->id || !font->outline || !font->metrics)
{
YLOG_ADD(YLOG_WARN, "Empty font declaration [line %d].",
node->line_nbr);
free0(font->outline);
free0(font->id);
free0(font);
return ;
}
font->f = -1;
if (!stat(font->outline, &st) && !stat(font->metrics, &st))
{
yv_add(&carta->fonts, font);
return ;
}
else
{
ystr_t ys1 = ys_new(""), ys2 = ys_new("");
int i;
for (i = 0; i < yv_len(carta->font_paths); ++i)
{
ys_printf(&ys1, "%s%c%s", carta->font_paths[i],
CARTA_SEP, font->outline);
ys_printf(&ys2, "%s%c%s", carta->font_paths[i],
CARTA_SEP, font->metrics);
if (!stat(ys1, &st) && !stat(ys2, &st))
{
free0(font->outline);
free0(font->metrics);
font->outline = ys_string(ys1);
font->metrics = ys_string(ys2);
yv_add(&carta->fonts, font);
ys_del(&ys1);
ys_del(&ys2);
return ;
}
}
ys_del(&ys1);
ys_del(&ys2);
}
YLOG_ADD(YLOG_WARN, "Unable to find files '%s' and '%s' in font paths.",
font->outline, font->metrics);
free_font(font, NULL);
}
/*
** free_font()
** Free the memory allocated for a font.
*/
void free_font(void *font, void *data)
{
cg_font_t *f = font;
if (!font)
return ;
free0(f->id);
free0(f->metrics);
free0(f->outline);
free0(f);
}
/*
** free_image()
** Free the memory allocated for an image.
*/
void free_image(void *image, void *data)
{
cg_image_t *i = image;
if (!image)
return ;
free0(i->id);
free0(i->file);
free0(i->mask);
free0(i->mask_id);
free0(i);
}
/*
** ydom_del()
** Delete a previously created XML DOM object and all memory allocated for it.
*/
void ydom_del(ydom_t *dom)
{
YLOG_MOD("ydom", YLOG_DEBUG, "Entering");
ydom_node_rm(dom->document_element);
if (dom->xml_version)
free0(dom->xml_version);
if (dom->encoding)
free0(dom->encoding);
if (dom->standalone)
free0(dom->standalone);
free0(dom);
YLOG_MOD("ydom", YLOG_DEBUG, "Exiting");
}
void addTemplate(int num, siginfo_t* info, void *other ) {
/* ------------------------- */
char* templateId = NULL;
long longRet = 0;
/* ------------------------- */
asprintf(&templateId, "%d", (info->si_value).sival_int);
PRINT_INFO("AWIZOJMSSERVERINF ADD NEW TEMPLATE TO CACHE\n");
PRINT_INFO("TEMPLATE ID : %d.\n", (info->si_value).sival_int );
/* ********************************************************* */
/* Odczyt szablonu z bazy i dodanie go do pamięci cache. */
/* ********************************************************* */
longRet = getDataFromDB( templateId, _GLOBAL_awizoConfig.dbase_handler, NULL );
if (longRet != BMD_OK){
PRINT_ERROR("Błędy w trakcie operacji zarządzania pamięcią cache. Error = %d\n", BMD_ERR_OP_FAILED);
}
sem_post(&(_GLOBAL_shptr->clientMutex));
free0(templateId);
}
/*
** ydom_new()
** Create a new XML DOM object.
*/
ydom_t *ydom_new()
{
ydom_t *dom;
ydom_node_t *node;
YLOG_MOD("ydom", YLOG_DEBUG, "Entering");
if (!(dom = malloc0(sizeof(ydom_t))))
{
YLOG_ADD(YLOG_ERR, "Unable to allocate memory");
return (NULL);
}
if (!(node = malloc0(sizeof(ydom_node_t))))
{
free0(dom);
YLOG_ADD(YLOG_ERR, "Unable to allocate memory");
return (NULL);
}
node->node_type = DOCUMENT_NODE;
node->complete = YTRUE;
node->name = NULL;
dom->error = YENOERR;
dom->document_element = dom->current_parsed_node = node;
YLOG_MOD("ydom", YLOG_DEBUG, "Exiting");
return (dom);
}
void free(void* ptr)
{
free0(ptr);
if (ptr == NULL) return;
char buf[MAX_BUFFER];
int pos = 0;
buf[pos++] = 'f';
buf[pos++] = ' ';
pos += hexdump(&buf[pos], (char*) &ptr, sizeof(ptr));
buf[pos++] = ' ';
size_t dummy = 0;
pos += hexdump(&buf[pos], (char*) &dummy, sizeof(dummy));
pos += dump_callstack(&buf[pos]);
buf[pos++] = '\n';
pthread_mutex_lock(&mutex);
write(fd, buf, pos);
pthread_mutex_unlock(&mutex);
}
/*
** ydom_node_add_text()
** Create a text node and insert it as a child of an existing node.
*/
ydom_node_t *ydom_node_add_text(ydom_node_t *node, char *data)
{
ydom_node_t *text_node = NULL;
char *tmp;
if (!node)
return (NULL);
if (node->last_child && node->last_child->node_type == TEXT_NODE)
{
tmp = malloc0(strlen(node->last_child->value) + strlen(data) + 1);
strcpy(tmp, node->last_child->value);
strcat(tmp, data);
free0(node->last_child->value);
node->last_child->value = tmp;
}
else
{
if (!(text_node = malloc0(sizeof(ydom_node_t))))
return (NULL);
text_node->node_type = TEXT_NODE;
text_node->value = str2xmlentity(data);
text_node->complete = YTRUE;
_ydom_add_child_to_node(node, text_node);
}
return (text_node);
}
/*
** _ydom_open_hdlr()
** DOM handler for SAX parsing
*/
static void _ydom_open_hdlr(ysax_t *sax, char *tag_name, yvect_t attrs)
{
ydom_t *dom;
ydom_node_t *node;
ysax_attr_t *pt;
YLOG_MOD("ydom", YLOG_DEBUG, "Entering");
dom = (ydom_t*)YSAX_DATA(sax);
if (!(node = malloc0(sizeof(ydom_node_t))))
{
YLOG_ADD(YLOG_ERR, "Memory alloc error");
return ;
}
node->node_type = ELEMENT_NODE;
node->name = tag_name;
node->line_nbr = sax->line_nbr;
while ((pt = yv_pop(attrs)))
{
_ydom_add_attr_to_node(node, pt->name, pt->value);
free0(pt);
}
yv_del(&attrs, NULL, NULL);
if (dom->current_parsed_node->node_type == TEXT_NODE)
{
dom->current_parsed_node->complete = YTRUE;
_ydom_add_next_to_node(dom->current_parsed_node, node);
}
else
_ydom_add_child_to_node(dom->current_parsed_node, node);
dom->current_parsed_node = node;
YLOG_MOD("ydom", YLOG_DEBUG, "Exiting");
}
/*
** ydom_node_rm_attributes()
** Remove all attributes of an XML node.
*/
void ydom_node_rm_attributes(ydom_node_t *node)
{
ydom_node_t *attr, *to_rm;
if (!node)
return ;
for (attr = node->attributes; attr; )
{
to_rm = attr;
attr = attr->next;
free0(to_rm->name);
free0(to_rm->value);
free0(to_rm);
}
node->attributes = NULL;
}
void free_BMD_attr(BMD_attr_t **attr)
{
long i;
if( (*attr)!=NULL )
{
free_gen_buf(&((*attr)->label));
free_gen_buf(&((*attr)->regexp));
free_gen_buf(&((*attr)->tooltip));
free_gen_buf(&((*attr)->depValueList));
free_gen_buf(&((*attr)->controlName));
i=0;
if((*attr)->valuesList)
{
while((*attr)->valuesList[i])
{
free_gen_buf(&((*attr)->valuesList[i]));
i++;
}
free((*attr)->valuesList);
}
i=0;
if((*attr)->priorityList)
{
free0((*attr)->priorityList);
}
free_gen_buf(&((*attr)->oid));
}
}
int ns__changeAdviceDispatchSetting(struct soap* soap, long dispatchSettingId, struct ns__awizoMessage* message, struct ns__dateTimeComplexList *dateTime, long *result) {
/* ------------------------------ */
long longRet = 0;
long attempt = 0;
queueNode_t* iterator = NULL;
char* host = NULL;
struct soap soap2Eawizo;
/* ------------------------------ */
attempt = MAX_ATTEMPT;
soap_init2(&soap2Eawizo,SOAP_C_UTFSTRING,SOAP_C_UTFSTRING);
iterator = (_GLOBAL_awizoConfig.bmdservers).head;
for(;;){
asprintf(&host, "http://%s:%s",((bmdserver_t*)(iterator->node))->addr,((bmdserver_t*)(iterator->node))->port);
longRet = soap_call_ns__changeAdviceDispatchSetting(&soap2Eawizo,host,NULL, dispatchSettingId, message, dateTime, result);
free0(host);
if (longRet == SOAP_OK) {
PRINT_INFO("Zapisano rekord w bazie danych\n");
return SOAP_OK;
}
else {
if (iterator->prev){
iterator=iterator->prev;
continue;
}
else if (--attempt <= 0){
PRINT_ERROR("Nie udało się nawiązać połączenia z żadnym z serwerów e-Awiz. Error = %d\n", BMD_ERR_OP_FAILED);
//soap_end(&soap2Eawizo);
//soap_done(&soap2Eawizo);
//return soap_receiver_fault(soap, "Nie udało się nawiązać połączenia z żadnym z serwerów e-Awiz.", NULL);
attempt = MAX_ATTEMPT;
}
iterator = (_GLOBAL_awizoConfig.bmdservers).head;
sleep(1);
}
}
soap_end(&soap2Eawizo);
soap_done(&soap2Eawizo);
return SOAP_OK;
}
/*
** free_path()
** Free the memory allocated for an include path.
*/
void free_path(void *path, void *data)
{
char *p = path;
if (!path)
return ;
free0(p);
}
/*
** ydom_set_standalone()
** Set the standalone state of the document.
*/
void ydom_set_standalone(ydom_t *dom, char *standalone)
{
if (!dom)
return ;
free0(dom->standalone);
if (standalone)
dom->standalone = strdup(standalone);
}
/*
** ydom_set_version()
** Set the version of XML language used in the document.
*/
void ydom_set_version(ydom_t *dom, char *version)
{
if (!dom)
return ;
free0(dom->xml_version);
if (version)
dom->xml_version = strdup(version);
}
/*
** ydom_set_encoding()
** Set the character encoding (like "iso-8859-1") of the document.
*/
void ydom_set_encoding(ydom_t *dom, char *encoding)
{
if (!dom)
return ;
free0(dom->encoding);
if (encoding)
dom->encoding = strdup(encoding);
}
long DeleteCorespondingDocs( void *hDB,
bmdDatagram_t *bmdJSRequest,
char *CryptoObjectNr,
char *location_id,
server_request_data_t *req)
{
long i = 0;
long ans_count = 0;
char **ans = NULL;
char *SQLQuery = NULL;
/************************/
/* walidacja parametrow */
/************************/
if (hDB==NULL) { BMD_FOK(BMD_ERR_PARAM1); }
if (CryptoObjectNr==NULL) { BMD_FOK(BMD_ERR_PARAM3); }
/*****************************************/
/* wyszukanie plikow korespondencujacych */
/*****************************************/
asprintf(&SQLQuery, "SELECT id FROM crypto_objects WHERE corresponding_id=%s%s%s;",
CryptoObjectNr,
location_id==NULL?"":" AND location_id=",
location_id==NULL?"":location_id);
BMD_FOK_NP(ExecuteSQLQueryWithAnswersKnownDBConnection( hDB, SQLQuery, &ans_count, &ans));
/*****************************************/
/* usuwanie dokumentow o znalezionych id */
/*****************************************/
for (i=0; i<ans_count; i++)
{
DeleteDocFromDatabase(hDB, bmdJSRequest, ans[i], location_id, req);
free0(ans[i]);
}
/************/
/* porzadki */
/************/
free0(ans);
free0(SQLQuery);
return BMD_OK;
}
int freeport(Obj p){
int (*fnc)(Obj);
int t = SUBPORT(p);
fnc = pdesc[t].free;
if(fnc) return fnc(p);
else return free0(p);
}
/*
** ydom_node_rm_children()
** Delete all children of an XML node, but node the node itself.
*/
void ydom_node_rm_children(ydom_node_t *node)
{
ydom_node_t *pt;
if (!node || !node->first_child)
return ;
while (node->first_child)
{
ydom_node_rm_children(node->first_child);
ydom_node_rm_attributes(node->first_child);
free0(node->first_child->name);
free0(node->first_child->value);
pt = node->first_child;
node->first_child = pt->next;
free0(pt);
}
node->last_child = NULL;
}
int ns__awizoDeleteSender(struct soap* soap, long id, long* result)
{
/* ------------------------------ */
long longRet = 0;
long attempt = 0;
queueNode_t* iterator = NULL;
char* host = NULL;
struct soap soap2Eawizo;
/* ------------------------------ */
attempt = MAX_ATTEMPT;
soap_init2(&soap2Eawizo,SOAP_C_UTFSTRING,SOAP_C_UTFSTRING);
iterator = (_GLOBAL_awizoConfig.bmdservers).head;
for(;;){
asprintf(&host, "http://%s:%s",((bmdserver_t*)(iterator->node))->addr,((bmdserver_t*)(iterator->node))->port);
longRet = soap_call_ns__awizoDeleteSender(&soap2Eawizo,host,NULL,id,result);
free0(host);
if (longRet == SOAP_OK) {
PRINT_INFO("Usunięto wystawcę o ID=%ld\n",id);
return SOAP_OK;
}
else {
if (iterator->prev){
iterator=iterator->prev;
continue;
}
else if (--attempt <= 0){
PRINT_ERROR("Nie udało się nawiązać połączenia z żadnym z serwerów e-Awiz. Error = %d\n", BMD_ERR_OP_FAILED);
//soap_end(&soap2Eawizo);
//soap_done(&soap2Eawizo);
//return soap_receiver_fault(soap, "Nie udało się nawiązać połączenia z żadnym z serwerów e-Awiz.", NULL);
attempt = MAX_ATTEMPT;
}
iterator = (_GLOBAL_awizoConfig.bmdservers).head;
sleep(1);
}
}
soap_end(&soap2Eawizo);
soap_done(&soap2Eawizo);
return SOAP_OK;
}
/*
** ydom_node_rm()
** Delete an XML node and all its children, and remove all links that point to it
** in the parent and siblings nodes.
*/
ydom_node_t *ydom_node_rm(ydom_node_t *node)
{
ydom_node_t *res;
if (!node)
return (NULL);
res = node->parent;
ydom_node_rm_children(node);
ydom_node_rm_attributes(node);
if (node->prev)
node->prev->next = node->next;
if (node->next)
node->next->prev = node->prev;
if (node->parent && node->parent->first_child == node)
node->parent->first_child = node->next;
if (node->parent && node->parent->last_child == node)
node->parent->last_child = node->prev;
free0(node->name);
free0(node->value);
free0(node);
return (res);
}
int eval(char** s, evalparser* e) {
int out = 0;
char* e_buf = 0;
e->index = 0;
while (e_txt(*s, e)) {
free0(e_buf);
e_buf = malloc(sizeof(char) * (strlen(e->nxt)+1));
strcpy(e_buf, e->nxt);
*s = e_buf;
e->index = 0;
e->nxt[0]=0;
out = 1;
}
free0(e_buf);
*s = e->nxt;
return out;
}
long SplitOidStringToPrefixAndSufix( char *OIDstring,
char **OIDstringPrefix,
char **OIDstringSufix)
{
char *c = NULL;
char *last_dot = NULL;
char *tmpOIDstring = NULL;
long dot_offset = 0;
long count = 0;
/************************/
/* walidacja parametrow */
/************************/
if(OIDstring == NULL) { BMD_FOK(BMD_ERR_PARAM1); }
if(OIDstringPrefix == NULL) { BMD_FOK(BMD_ERR_PARAM2); }
if(*OIDstringPrefix != NULL) { BMD_FOK(BMD_ERR_PARAM2); }
if(OIDstringSufix == NULL) { BMD_FOK(BMD_ERR_PARAM3); }
if(*OIDstringSufix != NULL) { BMD_FOK(BMD_ERR_PARAM3); }
asprintf(&tmpOIDstring, "%s", OIDstring);
if (tmpOIDstring==NULL) { BMD_FOK(NO_MEMORY); }
/*Znajdz lokalizacje ostatniej kropki*/
c = tmpOIDstring;
while(*c != 0)
{
if(*c == '.')
{
last_dot = c;
dot_offset = count;
}
c++;
count++;
}
*(tmpOIDstring+dot_offset) = 0;
/* w miejsce ostatniej kropki wstaw NULL i uzyskaj w ten sposob 2 stringi */
asprintf(OIDstringPrefix, "%s", tmpOIDstring);
if(*OIDstringPrefix == NULL) { BMD_FOK(NO_MEMORY); }
asprintf(OIDstringSufix, "%s", tmpOIDstring+dot_offset+1);
if(*OIDstringSufix == NULL) { BMD_FOK(NO_MEMORY); }
/************/
/* porzadki */
/************/
free0(tmpOIDstring);
return BMD_OK;
}
/*
** ydom_node_rm_attr()
** Remove the first attribute of an XML node that have a given name.
*/
void ydom_node_rm_attr(ydom_node_t *node, char *attr_name)
{
ydom_node_t *attr;
if (!node)
return ;
for (attr = node->attributes; attr; attr = attr->next)
{
if (!strcmp(attr_name, attr->name))
{
if (!attr->prev)
node->attributes = attr->next;
else
attr->prev->next = attr->next;
if (attr->next)
attr->next->prev = attr->prev;
free0(attr->name);
free0(attr->value);
free0(attr);
return ;
}
}
}
/*
** ytcp_server_set_nbr_threads()
** Set the number of threads to a given number. If there is more running
** threads than wanted number, only the waiting threads are ended. If there
** is less threads than desired, new ones are created.
*/
yerr_t ytcp_server_set_nbr_threads(ytcp_server_t *server, int nbr)
{
ytcp_thread_t *thread;
int i;
YLOG_MOD("ytcp", YLOG_DEBUG, "Entering");
if (nbr == server->nbr_threads)
return (YENOERR);
if (server->nbr_threads > nbr)
{
for (i = server->nbr_threads; i; --i)
{
thread = (ytcp_thread_t*)(server->vect_threads[i - 1]);
if (thread->state != YTCP_RUN)
{
thread = yv_ext(server->vect_threads, i);
thread->state = YTCP_CLOSE;
pthread_mutex_unlock(&(thread->mut_do));
pthread_join(thread->tid, NULL);
pthread_mutex_destroy(&(thread->mut_do));
free0(thread);
server->nbr_threads--;
}
}
}
while (server->nbr_threads < nbr)
{
thread = malloc0(sizeof(ytcp_thread_t));
pthread_mutex_init(&(thread->mut_do), NULL);
pthread_mutex_lock(&(thread->mut_do));
thread->server = server;
thread->data = ((ytcp_thread_t*)(server->vect_threads[0]))->data;
if (pthread_create(&(thread->tid), 0, _ytcp_server_thread_handle,
thread))
{
YLOG_ADD(YLOG_ERR, "Problem during thread creation");
thread->state = YTCP_CLOSE;
thread->fd = -1;
return (YEAGAIN);
}
yv_add(&(server->vect_threads), thread);
server->nbr_threads++;
thread->fd = -1;
thread->state = YTCP_WAIT;
}
YLOG_MOD("ytcp", YLOG_DEBUG, "Exiting");
return (YENOERR);
}
