cList *statbuf_to_list(struct stat * sbuf)
{
cList *list;
cData *d;
char buf[LINE];
register Int x;
list = list_new(5);
d = list_empty_spaces(list, 5);
for (x = 1; x < 5; x++)
d[x].type = INTEGER;
if (sizeof(sbuf->st_mode) == sizeof(long)) {
sprintf(buf, "%lo", (long unsigned int) (sbuf->st_mode));
} else {
sprintf(buf, "%o", sbuf->st_mode);
}
d[0].type = STRING;
d[0].u.str = string_from_chars(buf, strlen(buf));
d[1].u.val = (Int) sbuf->st_size;
d[2].u.val = (Int) sbuf->st_atime;
d[3].u.val = (Int) sbuf->st_mtime;
d[4].u.val = (Int) sbuf->st_ctime;
return list;
}
cStr *build_path(char *fname, struct stat * sbuf, Int nodir)
{
Int len = strlen(fname);
cStr *str = NULL;
if (len == 0)
THROWN((file_id, "No file specified."))
#ifdef RESTRICTIVE_FILES
if (strstr(fname, "../") || strstr(fname, "/..")
|| !strcmp(fname, ".."))
THROWN((perm_id, "Filename \"%s\" is not legal.", fname))
str = string_from_chars(c_dir_root, strlen(c_dir_root));
str = string_addc(str, '/');
str = string_add_chars(str, fname, len);
#else
if (*fname != '/') {
str = string_from_chars(c_dir_root, strlen(c_dir_root));
str = string_addc(str, '/');
str = string_add_chars(str, fname, len);
} else {
str = string_from_chars(fname, len);
}
#endif
if (sbuf != NULL) {
if (stat(str->s, sbuf) < 0) {
cthrow(file_id, "Cannot find file \"%s\".", str->s);
string_discard(str);
return NULL;
}
if (nodir) {
if (S_ISDIR(sbuf->st_mode)) {
cthrow(directory_id, "\"%s\" is a directory.", str->s);
string_discard(str);
return NULL;
}
}
}
return str;
}
/*
// Encrypt a string. The salt can be NULL--force SHS encryption,
// match_crypted() will handle older DES passwords
*/
cStr * strcrypt(cStr * key, cStr * salt) {
char pwd_buf[SHS_OUTPUT_SIZE]; /* output buffer for the password */
uChar * pp, * sp, rsalt[9]; /* 8 chars of salt, one NULL */
Int x,
pl,
sl;
if (!salt) {
random_salt:
for (x=0; x < 8; x++)
rsalt[x] = ascii64[random_number(64)];
rsalt[8] = 0;
sp = rsalt;
sl = 8;
} else {
sp = (uChar *) string_chars(salt);
if (sp[0] == '$' && sp[1] == '2' && sp[2] == '$') {
sp += 3;
for (x=0; x < 8 && sp[x] != '$'; x++)
rsalt[x] = sp[x];
rsalt[x] = 0;
sp = rsalt;
sl = strlen((char *) sp);
if (!sl)
goto random_salt;
} else {
sl = string_length(salt);
}
}
pp = (uChar *) string_chars(key);
pl = string_length(key);
shs_crypt(pp, pl, sp, sl, pwd_buf);
return string_from_chars(pwd_buf, strlen(pwd_buf));
}
/* Take an optional integer argument. */
if (!func_init_0_or_1(&args, &num_args, INTEGER))
return;
tval = (num_args) ? args[0].u.val : time(NULL);
#ifdef __BORLANDC__
if (tval < 18000) {
pop(num_args);
THROW((type_id,
"Borland's time util is broken, and requires time values above 18000"))
}
#endif
timestr = ctime(&tval);
str = string_from_chars(timestr, 24);
pop(num_args);
push_string(str);
string_discard(str);
}
COLDC_FUNC(bind_function) {
cData * args;
Int opcode;
/* accept a symbol and objnum */
if (!func_init_2(&args, SYMBOL, OBJNUM))
return;
opcode = find_function(ident_name(args[0].u.symbol));
/* void catch_signal(int sig, int code, struct sigcontext *scp) { */
void catch_signal(int sig)
{
char *sptr;
cStr *sigstr;
cData arg1;
Bool do_shutdown = NO;
signal(sig, catch_signal);
sptr = sig_name(sig);
sigstr = string_from_chars(sptr, strlen(sptr));
write_err("Caught signal %d: %S", sig, sigstr);
string_discard(sigstr);
/* figure out what to do */
switch (sig) {
#ifdef __UNIX__
case SIGHUP:
atomic = NO;
handle_connection_output();
flush_files();
#endif
#ifndef __MSVC__
case SIGUSR2:
/* let the db do what it wants from here */
break;
case SIGUSR1:
{
cData *d;
cList *l;
/* First cancel all preempted and suspended tasks */
l = vm_list();
for (d = list_first(l); d; d = list_next(l, d)) {
/* boggle */
if (d->type != INTEGER)
continue;
vm_cancel(d->u.val);
}
list_discard(l);
/* now cancel the current task if it is valid */
if (vm_lookup(task_id) != NULL) {
vm_cancel(task_id);
}
/* jump back to the main loop */
longjmp(main_jmp, 1);
break;
}
#endif
case SIGILL:
/* lets panic and hopefully shutdown without frobbing the db */
panic(sig_name(sig));
break;
case SIGTERM:
if (running) {
write_err("*** Attempting normal shutdown ***");
running = NO;
/* jump back to the main loop, ignore any current tasks;
*drip*, *drip*, leaky */
longjmp(main_jmp, 1);
} else {
panic(sig_name(sig));
}
break;
default:
do_shutdown = YES;
break;
}
/* only pass onto the db if we are 'executing' */
if (!running)
return;
/* send a message to the system object */
arg1.type = SYMBOL;
arg1.u.symbol = ident_get(sptr);
vm_task(SYSTEM_OBJNUM, signal_id, 1, &arg1);
if (do_shutdown)
running = NO;
}
int main()
{
init_util();
cList *keys = list_new(2);
cList *values = list_new(2);
cData key1, key2;
cData val1, val2;
key1.type = STRING;
key2.type = INTEGER;
key1.u.str = string_from_chars("ab", 2);
key2.u.val = 1106;
val1.type = val2.type = INTEGER;
val1.u.val = 10;
val2.u.val = 20;
list_add(keys, &key1);
list_add(keys, &key2);
values = list_add(values, &val1);
values = list_add(values, &val2);
cData keys_data, values_data;
keys_data.type = values_data.type = LIST;
keys_data.u.list = keys;
values_data.u.list = values;
cDict *mydict = dict_new(keys, values);
cStr *lit = string_new(0);
dict_add_literal_to_str(lit, mydict, 0);
printf("%s\n", lit->s);
printf("%s -> %d\n", key1.u.str->s, data_hash(&key1));
printf("%d -> %d\n", key2.u.val, data_hash(&key2));
puts("Testing dict!");
int i;
for (i = 0; i < mydict->hashtab_size; i++) {
printf("dict->links[%d] = %d\n", i, mydict->links[i]);
}
puts("");
for (i = 0; i < mydict->hashtab_size; i++) {
printf("dict->hashtab[%d] = %d\n", i, mydict->hashtab[i]);
}
puts("");
for (i = 0; i < list_length(values); i++) {
printf("dict->values[%d] = %s\n", i, data_to_literal(list_elem(mydict->values, i), 0)->s);
//printf("dict->values[%d] = %d\n", i, list_elem(values, i)->u.val);
}
/*puts("Find some valz!");
cData ret;
cData ret2;
long res = dict_find(mydict, &key1, &ret);
printf("%s => %d (%d)\n", key1.u.str->s, ret.u.val, res == keynf_id);
res = dict_find(mydict, &key2, &ret2);
printf("%s => %d (%d)\n", key2.u.str->s, ret2.u.val, res == keynf_id);
*/
return 0;
}
