/** Free the array with the name lists. */
void
free_names(gboolean reset)
{
#ifdef DEBUG
printf("free_names\n");
#endif
gint i;
if(name_lists == NULL)
{
if(reset)
name_lists = g_array_new(FALSE, FALSE, sizeof(NameList));
return;
}
for(i=0; i<name_lists->len; i++)
free_name_list(&g_array_index(name_lists, NameList, i), FALSE);
free_g_array(&name_lists);
if(reset)
name_lists = g_array_new(FALSE, FALSE, sizeof(NameList));
}
static bool print_tree(struct user_auth_info *user_info)
{
struct smb_name_list *wg, *sv, *sh;
/* List workgroups */
if (!get_workgroups(user_info))
return False;
for (wg = workgroups; wg; wg = wg->next) {
printf("%s\n", wg->name);
/* List servers */
free_name_list(servers);
servers = NULL;
if (level == LEV_WORKGROUP ||
!get_servers(wg->name, user_info))
continue;
for (sv = servers; sv; sv = sv->next) {
printf("\t\\\\%-15s\t\t%s\n",
sv->name, sv->comment);
/* List shares */
free_name_list(shares);
shares = NULL;
if (level == LEV_SERVER ||
!get_shares(sv->name, user_info))
continue;
for (sh = shares; sh; sh = sh->next) {
printf("\t\t\\\\%s\\%-15s\t%s\n",
sv->name, sh->name, sh->comment);
}
}
}
return True;
}
static void free_rx(RESTORE_CTX *rx)
{
free_bsr(rx->bsr);
rx->bsr = NULL;
free_and_null_pool_memory(rx->JobIds);
free_and_null_pool_memory(rx->BaseJobIds);
free_and_null_pool_memory(rx->fname);
free_and_null_pool_memory(rx->path);
free_and_null_pool_memory(rx->query);
free_name_list(&rx->name_list);
}
/** Fill the name list with names from the
given names file.
@param sid The sid of the names file we read.
@param namelist The name list we fill. */
void
xml_name_read(const gchar *sid, NameList *namelist)
{
#ifdef DEBUG
printf("xml_name_read\n");
#endif
gchar *file_name = NULL;
GMarkupParser parser = {xml_name_read_start_element,
xml_name_read_end_element,
xml_name_read_text, NULL, NULL};
GMarkupParseContext *context;
gchar *file_contents;
gsize length;
GError *error = NULL;
gchar buf[SMALL];
sprintf(buf, "player_names_%s.xml", sid);
file_name = file_find_support_file(buf, TRUE);
context =
g_markup_parse_context_new(&parser, 0, NULL, NULL);
if(!g_file_get_contents(file_name, &file_contents, &length, &error))
{
debug_print_message("xml_name_read: error reading file %s\n", file_name);
misc_print_error(&error, TRUE);
return;
}
free_name_list(namelist, TRUE);
misc_string_assign(&namelist->sid, sid);
nlist = namelist;
if(g_markup_parse_context_parse(context, file_contents, length, &error))
{
g_markup_parse_context_end_parse(context, NULL);
g_markup_parse_context_free(context);
g_free(file_contents);
}
else
{
g_critical("xml_name_read: error parsing file %s\n", buf);
misc_print_error(&error, TRUE);
}
g_free(file_name);
}
static void free_rx(RESTORE_CTX *rx)
{
free_bsr(rx->bsr);
rx->bsr = NULL;
if (rx->ClientName) {
free(rx->ClientName);
rx->ClientName = NULL;
}
if (rx->RestoreClientName) {
free(rx->RestoreClientName);
rx->RestoreClientName = NULL;
}
free_and_null_pool_memory(rx->JobIds);
free_and_null_pool_memory(rx->BaseJobIds);
free_and_null_pool_memory(rx->fname);
free_and_null_pool_memory(rx->path);
free_and_null_pool_memory(rx->query);
free_name_list(&rx->name_list);
}
void *get_serverlists(void *value)
{
struct name_list *wg, *sv;
//struct smbEventProxyCmd *pcmd = (struct smbEventProxyCmd *)cmd;
char buf[MAX_NAME_LEN] = {0};
int get_serverlists_by_nmblookup_state = 0; /*0:fail; 1:ok*/
int id = (int *)value;
struct smbEventProxyCmd *pevent = NULL;
char samba_workgroup[16] = {0};
#ifdef CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
securesoho_samba_workgroup_get(samba_workgroup);
#else //CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
get_serverlists_by_nmblookup_state = get_serverlists_by_nmblookup(id);
#endif //CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
/* List workgroups */
if(workgroups) {
free_name_list(workgroups);
workgroups = NULL;
}
if (!get_workgroups(&cmdline_auth_info)) {
is_getserver_done = 1;
#ifdef CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
SMBTREE_send_event_to_OSD(SMB_CMD_REFRESH_SERVER_RESPONSE, SMB_REFRESHED_FAILED, id, NULL);
printf("%s[%d], It's finish to search samba server(s).\n", __FILE__, __LINE__);
return NULL;
#else //CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
if(get_serverlists_by_nmblookup_state) {
SMBTREE_send_event_to_OSD(SMB_CMD_REFRESH_SERVER_RESPONSE, SMB_REFRESHED_OK, id, NULL);
printf("%s[%d], It's finish to search samba server(s). id:[%d]\n", __FILE__, __LINE__, id);
return NULL;
} else {
SMBTREE_send_event_to_OSD(SMB_CMD_REFRESH_SERVER_RESPONSE, SMB_REFRESHED_FAILED, id, NULL);
printf("%s[%d], It's finish to search samba server(s).\n", __FILE__, __LINE__);
return NULL;
}
#endif //CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
}
for (wg = workgroups; wg; wg = wg->next) {
#ifdef ENABLE_SMBTREE_DEBUG_MODE
printf("%s[%d], WorkGroup : [%s]\n", __FILE__, __LINE__, wg->name);
#endif //ENABLE_SMBTREE_DEBUG_MODE
/* List servers */
#ifdef CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
printf("samba_workgroup:[%s], wg->name:[%s]\n", samba_workgroup, wg->name);
if(strcasecmp(samba_workgroup, wg->name) != 0)
continue;
#endif //CONF_SAMBA_SUPPORT_ONLY_BROWSE_WORKGROUP_SERVERS
if(servers) {
free_name_list(servers);
servers = NULL;
}
if (level == LEV_WORKGROUP || !get_servers(wg->name, &cmdline_auth_info))
continue;
for (sv = servers; sv; sv = sv->next) {
char* ip = NULL;
nmblookup_ip(sv->name, &ip);
if(ip != NULL) {
snprintf(buf, sizeof(buf), "%s\\%s\\0", sv->name,ip);
#ifdef ENABLE_SMBTREE_DEBUG_MODE
printf("\t\\\\%-15s\t\t%s buf:%s\n", sv->name, sv->comment, buf);
#endif //ENABLE_SMBTREE_DEBUG_MODE
#ifdef ENABLE_PTHREAD
pevent = malloc(sizeof(struct smbEventProxyCmd));
pevent->cmd = SMB_CMD_REFRESH_SERVER_RESPONSE;
pevent->status = SMB_REFRESHING;
pevent->id = id;
pevent->datalen = strlen(buf) + 1;
strcpy((char *)pevent->data, buf);
XLinkedList_Lock(serverlist);
XLinkedList_AddTail(serverlist, (void *)pevent);
XLinkedList_UnLock(serverlist);
#else
SMBTREE_send_event_to_OSD(SMB_CMD_REFRESH_SERVER_RESPONSE, SMB_REFRESHING, id, buf);
#endif
free(ip);
ip = NULL;
}
}
}
printf("%s[%d], It's finish to search samba server(s). id:[%d]\n", __FILE__, __LINE__, id);
SMBTREE_send_event_to_OSD(SMB_CMD_REFRESH_SERVER_RESPONSE, SMB_REFRESHED_OK, id, NULL);
is_getserver_done = 1;
if(workgroups) {
free_name_list(workgroups);
workgroups = NULL;
}
if(servers) {
free_name_list(servers);
servers = NULL;
}
return NULL;
}
Code def_stat(Pnode p)
{
/*
def_stat
/
/
type ---> ID ---> ID
*/
int num_id = 0, op;
Code c_temp, code_ret;
Pname names;
Pnode nodo_type = p->child;
Pschema schema;
switch (nodo_type->type)
{
case N_ATOMIC_TYPE:
op = T_NEWATOM;
break;
case N_TABLE_TYPE:
op = T_NEWTAB;
break;
default:
noderror(p->child);
}
/* Operazioni comuni tra dati atomici e table */
// Carico la lista di ID delle variabili
names = id_list(p->child->brother, &num_id);
// Vincoli semantici
if (repeated_names(names))
semerror(p, "Variable redeclaration");
// Controlliamo che nessuna variabile sia nell'environment
Pname n;
for (n = names; n != NULL; n = n->next)
{
if (name_in_environment(n->name))
semerror(p, "Variable redeclaration");
// Aggiungo la nuova variabile nell'environment
insert_name_into_environment(n->name);
}
// Genero il codice per allocare ognuna delle variabili
code_ret.head = NULL;
for (n = names; n != NULL; n = n->next)
{
// Aggiungo il nome alla Symbol Table
schema = type(nodo_type);
schema->name = n->name;
insert(schema);
Value v1; v1.ival = get_size(schema);
c_temp = makecode1(op, v1);
code_ret = (code_ret.head == NULL ? c_temp : appcode(code_ret, c_temp));
}
// Liberiamo la memoria
free_name_list(names);
return code_ret;
}
static int
process_asl_data_store(asl_out_dst_data_t *dst)
{
int32_t today_ymd_stringlen, expire_ymd_stringlen;
time_t now, ttl, ymd_expire;
struct tm ctm;
char today_ymd_string[32], expire_ymd_string[32], *str;
DIR *dp;
struct dirent *dent;
name_list_t *ymd_list, *bb_list, *aux_list, *bb_aux_list, *e;
size_t file_size, store_size;
struct stat sb;
ymd_list = NULL;
bb_list = NULL;
aux_list = NULL;
bb_aux_list = NULL;
store_size = 0;
if (dst == NULL) return 0;
if (dst->path == NULL) return 0;
debug_log(ASL_LEVEL_NOTICE, "----------------------------------------\n");
debug_log(ASL_LEVEL_NOTICE, "Processing data store %s\n", dst->path);
if (dst->rotate_dir != NULL)
{
/* check archive */
memset(&sb, 0, sizeof(struct stat));
if (stat(dst->rotate_dir, &sb) == 0)
{
/* must be a directory */
if (!S_ISDIR(sb.st_mode))
{
debug_log(ASL_LEVEL_ERR, "aslmanager error: archive %s is not a directory", dst->rotate_dir);
return -1;
}
}
else
{
if (errno == ENOENT)
{
/* archive doesn't exist - create it */
if (mkdir(dst->rotate_dir, 0755) != 0)
{
debug_log(ASL_LEVEL_ERR, "aslmanager error: can't create archive %s: %s\n", dst->rotate_dir, strerror(errno));
return -1;
}
}
else
{
/* stat failed for some other reason */
debug_log(ASL_LEVEL_ERR, "aslmanager error: can't stat archive %s: %s\n", dst->rotate_dir, strerror(errno));
return -1;
}
}
}
chdir(dst->path);
/* determine current time */
now = time(NULL);
/* ttl 0 means files never expire */
ymd_expire = 0;
ttl = dst->ttl[LEVEL_ALL] * SECONDS_PER_DAY;
if ((ttl > 0) && (ttl <= now)) ymd_expire = now - ttl;
/* construct today's date as YYYY.MM.DD */
memset(&ctm, 0, sizeof(struct tm));
if (localtime_r((const time_t *)&now, &ctm) == NULL) return -1;
snprintf(today_ymd_string, sizeof(today_ymd_string), "%d.%02d.%02d.", ctm.tm_year + 1900, ctm.tm_mon + 1, ctm.tm_mday);
today_ymd_stringlen = strlen(today_ymd_string);
/* construct regular file expiry date as YYYY.MM.DD */
memset(&ctm, 0, sizeof(struct tm));
if (localtime_r((const time_t *)&ymd_expire, &ctm) == NULL) return -1;
snprintf(expire_ymd_string, sizeof(expire_ymd_string), "%d.%02d.%02d.", ctm.tm_year + 1900, ctm.tm_mon + 1, ctm.tm_mday);
expire_ymd_stringlen = strlen(expire_ymd_string);
debug_log(ASL_LEVEL_NOTICE, "Expiry Date %s\n", expire_ymd_string);
dp = opendir(dst->path);
if (dp == NULL) return -1;
/* gather a list of YMD files, AUX dirs, BB.AUX dirs, and BB files */
while ((dent = readdir(dp)) != NULL)
{
memset(&sb, 0, sizeof(struct stat));
file_size = 0;
if (stat(dent->d_name, &sb) == 0) file_size = sb.st_size;
if ((dent->d_name[0] >= '0') && (dent->d_name[0] <= '9'))
{
ymd_list = add_to_name_list(ymd_list, dent->d_name, file_size);
store_size += file_size;
}
else if (!strncmp(dent->d_name, "AUX.", 4) && (dent->d_name[4] >= '0') && (dent->d_name[4] <= '9') && S_ISDIR(sb.st_mode))
{
file_size = directory_size(dent->d_name);
aux_list = add_to_name_list(aux_list, dent->d_name, file_size);
store_size += file_size;
}
else if (!strncmp(dent->d_name, "BB.AUX.", 7) && (dent->d_name[7] >= '0') && (dent->d_name[7] <= '9') && S_ISDIR(sb.st_mode))
{
file_size = directory_size(dent->d_name);
bb_aux_list = add_to_name_list(bb_aux_list, dent->d_name, file_size);
store_size += file_size;
}
else if (!strncmp(dent->d_name, "BB.", 3) && (dent->d_name[3] >= '0') && (dent->d_name[3] <= '9'))
{
bb_list = add_to_name_list(bb_list, dent->d_name, file_size);
store_size += file_size;
}
else if ((!strcmp(dent->d_name, ".")) || (!strcmp(dent->d_name, "..")))
{}
else if ((!strcmp(dent->d_name, "StoreData")) || (!strcmp(dent->d_name, "SweepStore")))
{}
else
{
debug_log(ASL_LEVEL_ERR, "aslmanager: unexpected file %s in ASL data store\n", dent->d_name);
}
}
closedir(dp);
debug_log(ASL_LEVEL_NOTICE, "Data Store Size = %lu\n", store_size);
debug_log(ASL_LEVEL_NOTICE, "Data Store YMD Files\n");
for (e = ymd_list; e != NULL; e = e->next) debug_log(ASL_LEVEL_NOTICE, " %s %lu\n", e->name, e->size);
debug_log(ASL_LEVEL_NOTICE, "Data Store AUX Directories\n");
for (e = aux_list; e != NULL; e = e->next) debug_log(ASL_LEVEL_NOTICE, " %s %lu\n", e->name, e->size);
debug_log(ASL_LEVEL_NOTICE, "Data Store BB.AUX Directories\n");
for (e = bb_aux_list; e != NULL; e = e->next) debug_log(ASL_LEVEL_NOTICE, " %s %lu\n", e->name, e->size);
debug_log(ASL_LEVEL_NOTICE, "Data Store BB Files\n");
for (e = bb_list; e != NULL; e = e->next) debug_log(ASL_LEVEL_NOTICE, " %s %lu\n", e->name, e->size);
/* Delete/achive expired YMD files */
debug_log(ASL_LEVEL_NOTICE, "Start YMD File Scan\n");
e = ymd_list;
while (e != NULL)
{
if (strncmp(e->name, expire_ymd_string, expire_ymd_stringlen) <= 0)
{
/* file has expired, archive it if required, then unlink it */
if (dst->rotate_dir != NULL)
{
str = NULL;
asprintf(&str, "%s/%s", dst->rotate_dir, e->name);
if (str == NULL) return -1;
filesystem_copy(dst, e->name, str, 0);
free(str);
}
filesystem_unlink(e->name);
store_size -= e->size;
e->size = 0;
}
else
{
/* check if there are any per-level TTLs and filter the file if required */
uint32_t i, bit, keep_mask;
uid_t ymd_uid = -1;
gid_t ymd_gid = -1;
mode_t ymd_mode = 0600;
uint32_t age = ymd_file_age(e->name, now, &ymd_uid, &ymd_gid);
if (age > 0)
{
keep_mask = 0x000000ff;
bit = 1;
for (i = 0; i <= 7; i++)
{
if ((dst->ttl[i] > 0) && (age >= dst->ttl[i])) keep_mask &= ~bit;
bit *= 2;
}
memset(&sb, 0, sizeof(struct stat));
if (stat(e->name, &sb) == 0) ymd_mode = sb.st_mode & 0777;
if (keep_mask != 0x000000ff) ymd_file_filter(e->name, dst->path, keep_mask, ymd_mode, ymd_uid, ymd_gid);
}
}
e = e->next;
}
debug_log(ASL_LEVEL_NOTICE, "Finished YMD File Scan\n");
/* Delete/achive expired YMD AUX directories */
debug_log(ASL_LEVEL_NOTICE, "Start AUX Directory Scan\n");
e = aux_list;
while (e != NULL)
{
/* stop when a file name/date is after the expire date */
if (strncmp(e->name + 4, expire_ymd_string, expire_ymd_stringlen) > 0) break;
if (dst->rotate_dir != NULL)
{
str = NULL;
asprintf(&str, "%s/%s", dst->rotate_dir, e->name);
if (str == NULL) return -1;
filesystem_copy(dst, e->name, str, 0);
free(str);
}
remove_directory(e->name);
store_size -= e->size;
e->size = 0;
e = e->next;
}
debug_log(ASL_LEVEL_NOTICE, "Finished AUX Directory Scan\n");
/* Delete/achive expired BB.AUX directories */
debug_log(ASL_LEVEL_NOTICE, "Start BB.AUX Directory Scan\n");
e = bb_aux_list;
while (e != NULL)
{
/* stop when a file name/date is after the expire date */
if (strncmp(e->name + 7, today_ymd_string, today_ymd_stringlen) > 0) break;
if (dst->rotate_dir != NULL)
{
str = NULL;
asprintf(&str, "%s/%s", dst->rotate_dir, e->name);
if (str == NULL) return -1;
filesystem_copy(dst, e->name, str, 0);
free(str);
}
remove_directory(e->name);
store_size -= e->size;
e->size = 0;
e = e->next;
}
debug_log(ASL_LEVEL_NOTICE, "Finished BB.AUX Directory Scan\n");
/* Delete/achive expired BB files */
debug_log(ASL_LEVEL_NOTICE, "Start BB Scan\n");
e = bb_list;
while (e != NULL)
{
/* stop when a file name/date is after the expire date */
if (strncmp(e->name + 3, today_ymd_string, today_ymd_stringlen) > 0) break;
if (dst->rotate_dir != NULL)
{
str = NULL;
asprintf(&str, "%s/%s", dst->rotate_dir, e->name);
if (str == NULL) return -1;
/* syslog -x [str] -f [e->name] */
filesystem_copy(dst, e->name, str, 0);
free(str);
}
filesystem_unlink(e->name);
store_size -= e->size;
e->size = 0;
e = e->next;
}
debug_log(ASL_LEVEL_NOTICE, "Finished BB Scan\n");
if (dst->all_max > 0)
{
/* if data store is over max_size, delete/archive more YMD files */
if (store_size > dst->all_max) debug_log(ASL_LEVEL_NOTICE, "Additional YMD Scan\n");
e = ymd_list;
while ((e != NULL) && (store_size > dst->all_max))
{
if (e->size != 0)
{
if (strncmp(e->name, today_ymd_string, today_ymd_stringlen) == 0)
{
/* do not touch active file YYYY.MM.DD.asl */
if (strcmp(e->name + today_ymd_stringlen, "asl") == 0)
{
e = e->next;
continue;
}
}
if (dst->rotate_dir != NULL)
{
str = NULL;
asprintf(&str, "%s/%s", dst->rotate_dir, e->name);
if (str == NULL) return -1;
/* syslog -x [str] -f [e->name] */
filesystem_copy(dst, e->name, str, 0);
free(str);
}
filesystem_unlink(e->name);
store_size -= e->size;
e->size = 0;
}
e = e->next;
}
/* if data store is over dst->all_max, delete/archive more BB files */
if (store_size > dst->all_max) debug_log(ASL_LEVEL_NOTICE, "Additional BB Scan\n");
e = bb_list;
while ((e != NULL) && (store_size > dst->all_max))
{
if (e->size != 0)
{
if (dst->rotate_dir != NULL)
{
str = NULL;
asprintf(&str, "%s/%s", dst->rotate_dir, e->name);
if (str == NULL) return -1;
/* syslog -x [str] -f [e->name] */
filesystem_copy(dst, e->name, str, 0);
free(str);
}
filesystem_unlink(e->name);
store_size -= e->size;
e->size = 0;
}
e = e->next;
}
}
free_name_list(ymd_list);
free_name_list(bb_list);
free_name_list(aux_list);
free_name_list(bb_aux_list);
debug_log(ASL_LEVEL_NOTICE, "Data Store Size = %lu\n", store_size);
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
char filename[256];
mxArray *pa1;
mxArray **mat_elem;
double *matData;
const char *field_name[20] = {"name","data"};
int i,j,count;
HEADER_FRAME *first_header_frame;
DATA_FRAME *first_data_frame, *cur_data_frame;
NAME_LIST *first_sig_name, *cur_sig_name;
int num_sigs,num_samples;
first_data_frame = init_data_frame();
first_header_frame = init_header_frame();
first_sig_name = init_name_list();
if (nrhs != 1)
mexErrMsgTxt("Error: missing filename. Usage: x = loadsig_cppsim('filename')");
if (!mxIsChar(prhs[0]))
mexErrMsgTxt("Error: filename must be a string");
if (nlhs != 1)
mexErrMsgTxt("Error: missing output variable. Usage: x = loadsig_cppsim('filename')");
mxGetString(prhs[0],filename,255);
if (load_data_from_file(filename,first_header_frame,first_data_frame,
&num_sigs, &num_samples) == -1)
mexErrMsgTxt("File not read");
extract_signal_names(first_header_frame,num_sigs,first_sig_name);
/* write into MATLAB structure */
plhs[0] = mxCreateStructMatrix(num_sigs,1,2,field_name);
/* copy signal name */
cur_sig_name = first_sig_name;
for (i = 0; i < num_sigs; i++)
{
pa1 = mxCreateString(cur_sig_name->name);
mxSetField(plhs[0],i,field_name[0],pa1);
cur_sig_name = cur_sig_name->next;
}
/* copy data */
if ((mat_elem = (mxArray **) mxCalloc(num_sigs,sizeof(mxArray *))) == NULL)
{
mexPrintf("error in loadsig_cppsim: calloc call failed - \n");
mexPrintf(" not enough memory!!\n");
return;
}
for (i = 0; i < num_sigs; i++)
mat_elem[i] = mxCreateDoubleMatrix(num_samples,1,mxREAL);
cur_data_frame = first_data_frame;
count = 0;
for (j = 0; j < num_samples; j++)
{
for (i = 0; i < num_sigs; i++)
{
if (count == cur_data_frame->length)
{
cur_data_frame = cur_data_frame->next;
if (cur_data_frame == NULL)
{
mexPrintf("error: data frame too short!\n");
return;
}
count = 0;
}
matData = mxGetPr(mat_elem[i]);
if (cur_data_frame->data_type == 32)
matData[j] = cur_data_frame->fbuf[count];
else
matData[j] = cur_data_frame->dbuf[count];
count++;
}
}
for (i = 0; i < num_sigs; i++)
mxSetField(plhs[0],i,field_name[1],mat_elem[i]);
free_header_frames(first_header_frame);
free_data_frames(first_data_frame);
free_name_list(first_sig_name);
return;
}
