int
main(const int argc, const char *argv[])
{
PERSON *ajout = NULL;
int choice = 0;
char temp[3] = "";
clear_screen();
create_users_file(USERSFILE);
set_index_birthdays();
check_argument(argc, argv);
do
{
printf("\t\n1. Encoder un nouvel anniversaire");
printf("\t\n2. Afficher les anniversaires");
printf("\t\n3. Charger un fichier d'anniversaires");
printf("\t\n4. Sauvegarder les anniversaires sur fich ier");
printf("\t\n5. Afficher le prochain anniversaire");
printf("\t\n6. Supprimer les anniversaires en cours");
printf("\t\n7. Supprimer un anniversaire");
printf("\t\n8. Quitter");
printf("\t\n\nVotre choix: ");
fgets(temp, sizeof(temp), stdin);
choice = atoi(temp);
clean_string(temp);
switch(choice)
{
case 1: set_birthday(&ajout);
add_birthday(ajout);
free(ajout);
ajout = NULL;
break;
case 2: print_birthdays();
break;
case 3: load_birthdays();
break;
case 4: save_birthdays();
break;
case 5: print_next_birthday();
break;
case 6: clean_birthdays();
break;
case 7: delete_birthday();
break;
default:
break;
}
if( choice != 8 )
{
press_enter_to_continue();
clear_screen();
}
}while( choice != 8 );
clean_birthdays();
clean_errno();
return EXIT_SUCCESS;
}
char *gparser_next_line(gparser_t *parser) {
char read_buffer[512] = {0};
char *line = NULL;
char *rc = NULL;
// Sanity check the stream before we go on,
check_debug(feof(parser->stream) == 0, "parser(%p)[%s]:%zd is at EOF", parser, parser->path, parser->line);
check(ferror(parser->stream) == 0, "Error in parser(%p)[%s]:%zd stream.", parser, parser->path, parser->line);
// Advance the line first
parser->line++;
// Try reading, with the hope that we get the entire line at once
rc = fgets(read_buffer, sizeof(read_buffer), parser->stream);
check(rc != NULL, "Failed to read line from '%s':%zd", parser->path, parser->line);
check_mem(line = calloc(strlen(read_buffer) + 1, sizeof(char)));
strncpy(line, read_buffer, strlen(read_buffer));
// See if we need to finish reading the line
while(line[strlen(line) - 1] != '\n') {
rc = fgets(read_buffer, sizeof(read_buffer), parser->stream);
if((rc == NULL) && feof(parser->stream)) {
// We got everything that we can get, so we'll
// call it a "line"
break;
}
else {
// Append the new data to the end of the line
char *new_line = NULL;
check(rc != NULL, "Error finishing line %s:%zd", parser->path, parser->line);
check_mem(new_line = calloc(strlen(line) + strlen(read_buffer) + 1, sizeof(char)));
strncpy(new_line, line, strlen(line));
strncpy(new_line + strlen(new_line), read_buffer, strlen(read_buffer));
free(line);
line = new_line;
}
}
return line;
error:
if(line != NULL) free(line);
if(feof(parser->stream)) debug("parser(%p)[%s]:%zd: EOF", parser, parser->path, parser->line);
if(ferror(parser->stream)) debug("parser(%p)[%s]:%zd: ERROR. %s", parser, parser->path, parser->line, clean_errno());
return NULL;
}
size_t fcgi_env_write(uint8_t *ptr,
const size_t len,
struct client_session *cs,
struct session_request *sr)
{
mk_pointer key, value;
char buffer[128];
char *tmpuri = NULL;
size_t pos = 0;
struct sockaddr_in addr;
socklen_t addr_len;
unsigned int i, j;
char *hinit, *hend;
size_t hlen;
mk_api->pointer_set(&key, "PATH_INFO");
mk_api->pointer_set(&value, "");
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "GATEWAY_INTERFACE");
mk_api->pointer_set(&value, "CGI/1.1");
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "REDIRECT_STATUS");
mk_api->pointer_set(&value, "200");
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "SERVER_SOFTWARE");
mk_api->pointer_set(&value, sr->host_conf->host_signature);
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "DOCUMENT_ROOT");
value = sr->host_conf->documentroot;
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "SERVER_PROTOCOL");
value = sr->protocol_p;
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "SERVER_NAME");
value.data = sr->host_alias->name;
value.len = sr->host_alias->len;
__write_param(ptr, len, pos, key, value);
addr_len = sizeof(addr);
if (!getsockname(cs->socket, (struct sockaddr *)&addr, &addr_len)) {
if (!inet_ntop(AF_INET, &addr.sin_addr, buffer, 128)) {
log_warn("Failed to get bound address.");
buffer[0] = '\0';
}
mk_api->pointer_set(&key, "SERVER_ADDR");
mk_api->pointer_set(&value, buffer);
__write_param(ptr, len, pos, key, value);
snprintf(buffer, 128, "%d", ntohs(addr.sin_port));
mk_api->pointer_set(&key, "SERVER_PORT");
mk_api->pointer_set(&value, buffer);
__write_param(ptr, len, pos, key, value);
} else {
log_warn("%s", clean_errno());
errno = 0;
}
mk_api->pointer_set(&key, "SCRIPT_FILENAME");
value = sr->real_path;
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "SCRIPT_NAME");
value = sr->uri_processed;
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "REQUEST_METHOD");
value = sr->method_p;
__write_param(ptr, len, pos, key, value);
addr_len = sizeof(addr);
if (!getpeername(cs->socket, (struct sockaddr *)&addr, &addr_len)) {
inet_ntop(AF_INET, &addr.sin_addr, buffer, 128);
mk_api->pointer_set(&key, "REMOTE_ADDR");
mk_api->pointer_set(&value, buffer);
__write_param(ptr, len, pos, key, value);
snprintf(buffer, 128, "%d", ntohs(addr.sin_port));
mk_api->pointer_set(&key, "REMOTE_PORT");
mk_api->pointer_set(&value, buffer);
__write_param(ptr, len, pos, key, value);
} else {
log_warn("%s", clean_errno());
errno = 0;
}
mk_api->pointer_set(&key, "REQUEST_URI");
if (sr->query_string.len > 0) {
value.len = sr->uri.len + sr->query_string.len + 2;
tmpuri = mk_api->mem_alloc(value.len);
check_mem(tmpuri);
value.data = tmpuri;
snprintf(value.data, value.len, "%.*s?%.*s",
(int)sr->uri.len, sr->uri.data,
(int)sr->query_string.len, sr->query_string.data);
} else {
value = sr->uri;
}
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "QUERY_STRING");
value = sr->query_string;
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "CONTENT_TYPE");
value = sr->content_type;
__write_param(ptr, len, pos, key, value);
mk_api->pointer_set(&key, "CONTENT_LENGTH");
snprintf(buffer, 128, "%d", sr->content_length);
mk_api->pointer_set(&value, buffer);
__write_param(ptr, len, pos, key, value);
strcpy(buffer, "HTTP_");
for (i = 0; i < (unsigned int)sr->headers_toc.length; i++) {
hinit = sr->headers_toc.rows[i].init;
hend = sr->headers_toc.rows[i].end;
hlen = hend - hinit;
for (j = 0; j < hlen; j++) {
if (hinit[j] == ':') {
break;
}
else if (hinit[j] != '-') {
buffer[5 + j] = toupper(hinit[j]);
}
else {
buffer[5 + j] = '_';
}
}
key = (mk_pointer){.len = 5 + j, .data = buffer};
value = (mk_pointer){.len = hlen - j - 2, .data = hinit + j + 2};
__write_param(ptr, len, pos, key, value);
}
if (tmpuri) mk_api->mem_free(tmpuri);
return pos;
error:
if (tmpuri) mk_api->mem_free(tmpuri);
return pos;
}
static VALUE method_zkrb_iterate_event_loop(VALUE self) {
FETCH_DATA_PTR(self, zk);
fd_set rfds, wfds, efds;
FD_ZERO(&rfds); FD_ZERO(&wfds); FD_ZERO(&efds);
int fd=0, interest=0, events=0, rc=0, maxfd=0;
struct timeval tv;
zookeeper_interest(zk->zh, &fd, &interest, &tv);
if (fd != -1) {
if (interest & ZOOKEEPER_READ) {
FD_SET(fd, &rfds);
} else {
FD_CLR(fd, &rfds);
}
if (interest & ZOOKEEPER_WRITE) {
FD_SET(fd, &wfds);
} else {
FD_CLR(fd, &wfds);
}
} else {
fd = 0;
}
// add our self-pipe to the read set, allow us to wake up in case our attention is needed
int pipe_r_fd = get_self_pipe_read_fd(self);
FD_SET(pipe_r_fd, &rfds);
maxfd = (pipe_r_fd > fd) ? pipe_r_fd : fd;
rc = rb_thread_select(maxfd+1, &rfds, &wfds, &efds, &tv);
if (rc > 0) {
if (FD_ISSET(fd, &rfds)) {
events |= ZOOKEEPER_READ;
}
if (FD_ISSET(fd, &wfds)) {
events |= ZOOKEEPER_WRITE;
}
// we got woken up by the self-pipe
if (FD_ISSET(pipe_r_fd, &rfds)) {
// one event has awoken us, so we clear one event from the pipe
char b[1];
if (read(pipe_r_fd, b, 1) < 0) {
rb_raise(rb_eRuntimeError, "read from pipe failed: %s", clean_errno());
}
}
rc = zookeeper_process(zk->zh, events);
}
else if (rc == 0) {
zkrb_debug("timed out waiting for descriptor to be ready");
}
else {
log_err("select returned: %d", rc);
}
return INT2FIX(rc);
}
