void *filenew(char *name, char *path, DIR *dir, t_args *args)
{
t_file *file;
file = MAL1(t_file);
file->stats = MAL1(struct stat);
file->path = ft_stringnew();
ft_stringadd(file->path, path);
while (file->path->length > 1 &&
file->path->content[file->path->length - 1] == '/')
ft_stringrem(file->path, file->path->length - 1, 1);
if (file->path->length > 0 && name[0] != '/' &&
file->path->content[file->path->length - 1] != '/')
ft_stringaddc(file->path, '/');
ft_stringadd(file->path, name);
file->dir = dir;
file->name = NULL;
if (FLAG(FLAG_STAT) && lstat(file->path->content, file->stats) < 0)
{
print_errno(name, errno);
kill_file(file);
return (NULL);
}
file->real = name;
file->name = get_name(file, name, args);
return ((void*)file);
}
void server_shutdown(server_startup_st *construct)
{
if (construct->server_list)
{
for (uint32_t x= 0; x < construct->count; x++)
{
char file_buffer[PATH_MAX]; /* Nothing special for number */
snprintf(file_buffer, sizeof(file_buffer), PID_FILE_BASE, x);
kill_file(file_buffer);
}
free(construct->server_list);
}
}
void tedit_string_cleanup(struct descriptor_data *d, int terminator)
{
FILE *fl;
char *storage = OLC_STORAGE(d);
if (!storage)
terminator = STRINGADD_ABORT;
switch (terminator) {
case STRINGADD_SAVE:
if (OLC(d)->kill_on_empty && (!(*d->str) || **d->str == '\0')) {
if (kill_file(storage)) {
sprintf(buf, "SYSERR: Can't delete file '%s'.", storage);
mudlog(buf, CMP, LVL_IMPL, TRUE);
} else {
sprintf(buf, "OLC: %s deletes '%s'.", GET_NAME(d->character), storage);
mudlog(buf, CMP, LVL_GOD, TRUE);
write_to_output(d, "Deleted.\r\n");
}
} else if (!(fl = fopen(storage, "w"))) {
sprintf(buf, "SYSERR: Can't write file '%s'.", storage);
mudlog(buf, CMP, LVL_IMPL, TRUE);
} else {
if (*d->str) {
strip_string(*d->str);
fputs(*d->str, fl);
}
fclose(fl);
sprintf(buf, "OLC: %s saves '%s'.", GET_NAME(d->character), storage);
mudlog(buf, CMP, LVL_GOD, TRUE);
write_to_output(d, "Saved.\r\n");
}
break;
case STRINGADD_ABORT:
write_to_output(d, "Edit aborted.\r\n");
act("$n stops editing some scrolls.", TRUE, d->character, 0, 0, TO_ROOM);
break;
default:
log("SYSERR: tedit_string_cleanup: Unknown terminator status.");
break;
}
/* Common cleanup code. */
cleanup_olc(d, CLEANUP_ALL);
STATE(d) = CON_PLAYING;
}
void server_startup(server_startup_st *construct)
{
if ((construct->server_list= getenv("MEMCACHED_SERVERS")))
{
printf("servers %s\n", construct->server_list);
construct->servers= memcached_servers_parse(construct->server_list);
construct->server_list= NULL;
construct->count= 0;
}
else
{
{
char server_string_buffer[8096];
char *end_ptr;
end_ptr= server_string_buffer;
for (uint32_t x= 0; x < construct->count; x++)
{
int count;
int status;
in_port_t port;
{
char *var;
char variable_buffer[1024];
snprintf(variable_buffer, sizeof(variable_buffer), "LIBMEMCACHED_PORT_%u", x);
if ((var= getenv(variable_buffer)))
{
port= (in_port_t)atoi(var);
}
else
{
port= (in_port_t)(x + TEST_PORT_BASE);
}
}
char buffer[PATH_MAX];
snprintf(buffer, sizeof(buffer), PID_FILE_BASE, x);
kill_file(buffer);
if (x == 0)
{
snprintf(buffer, sizeof(buffer), "%s -d -u root -P "PID_FILE_BASE" -t 1 -p %u -U %u -m 128",
MEMCACHED_BINARY, x, port, port);
}
else
{
snprintf(buffer, sizeof(buffer), "%s -d -u root -P "PID_FILE_BASE" -t 1 -p %u -U %u",
MEMCACHED_BINARY, x, port, port);
}
if (libmemcached_util_ping("localhost", port, NULL))
{
fprintf(stderr, "Server on port %u already exists\n", port);
}
else
{
status= system(buffer);
fprintf(stderr, "STARTING SERVER: %s status:%d\n", buffer, status);
}
count= sprintf(end_ptr, "localhost:%u,", port);
end_ptr+= count;
}
*end_ptr= 0;
int *pids= calloc(construct->count, sizeof(int));
for (uint32_t x= 0; x < construct->count; x++)
{
char buffer[PATH_MAX]; /* Nothing special for number */
snprintf(buffer, sizeof(buffer), PID_FILE_BASE, x);
uint32_t counter= 3000; // Absurd, just to catch run away process
while (pids[x] <= 0 && --counter)
{
FILE *file= fopen(buffer, "r");
if (file)
{
char pid_buffer[1024];
char *found= fgets(pid_buffer, sizeof(pid_buffer), file);
if (found)
{
pids[x]= atoi(pid_buffer);
fclose(file);
if (pids[x] > 0)
break;
}
fclose(file);
}
global_sleep();
}
bool was_started= false;
if (pids[x] > 0)
{
counter= 30;
while (--counter)
{
if (kill(pids[x], 0) == 0)
{
was_started= true;
break;
}
global_sleep();
}
}
if (was_started == false)
{
fprintf(stderr, "Failed to open buffer %s(%d)\n", buffer, pids[x]);
for (uint32_t y= 0; y < construct->count; y++)
{
if (pids[y] > 0)
kill(pids[y], SIGTERM);
}
abort();
}
}
free(pids);
construct->server_list= strdup(server_string_buffer);
}
printf("servers %s\n", construct->server_list);
construct->servers= memcached_servers_parse(construct->server_list);
}
assert(construct->servers);
srandom((unsigned int)time(NULL));
for (uint32_t x= 0; x < memcached_server_list_count(construct->servers); x++)
{
printf("\t%s : %d\n", memcached_server_name(&construct->servers[x]), memcached_server_port(&construct->servers[x]));
assert(construct->servers[x].fd == -1);
assert(construct->servers[x].cursor_active == 0);
}
printf("\n");
}
