static void read_cb(void *user_data, int success) {
struct read_socket_state *state = (struct read_socket_state *)user_data;
ssize_t read_bytes;
int current_data;
GPR_ASSERT(success);
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
current_data = state->read_bytes % 256;
read_bytes = count_slices(state->incoming.slices, state->incoming.count,
¤t_data);
state->read_bytes += read_bytes;
gpr_log(GPR_INFO, "Read %d bytes of %d", read_bytes,
state->target_read_bytes);
if (state->read_bytes >= state->target_read_bytes) {
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
} else {
switch (grpc_endpoint_read(state->ep, &state->incoming, &state->read_cb)) {
case GRPC_ENDPOINT_DONE:
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
read_cb(user_data, 1);
break;
case GRPC_ENDPOINT_ERROR:
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
read_cb(user_data, 0);
break;
case GRPC_ENDPOINT_PENDING:
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
break;
}
}
}
/* Write to a socket until it fills up, then read from it using the grpc_tcp
API. */
static void large_read_test(ssize_t slice_size) {
int sv[2];
grpc_endpoint *ep;
struct read_socket_state state;
ssize_t written_bytes;
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20);
gpr_log(GPR_INFO, "Start large read test, slice size %d", slice_size);
create_sockets(sv);
ep = grpc_tcp_create(grpc_fd_create(sv[1], "large_read_test"), slice_size,
"test");
grpc_endpoint_add_to_pollset(ep, &g_pollset);
written_bytes = fill_socket(sv[0]);
gpr_log(GPR_INFO, "Wrote %d bytes", written_bytes);
state.ep = ep;
state.read_bytes = 0;
state.target_read_bytes = written_bytes;
gpr_slice_buffer_init(&state.incoming);
grpc_iomgr_closure_init(&state.read_cb, read_cb, &state);
switch (grpc_endpoint_read(ep, &state.incoming, &state.read_cb)) {
case GRPC_ENDPOINT_DONE:
read_cb(&state, 1);
break;
case GRPC_ENDPOINT_ERROR:
read_cb(&state, 0);
break;
case GRPC_ENDPOINT_PENDING:
break;
}
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
while (state.read_bytes < state.target_read_bytes) {
grpc_pollset_worker worker;
grpc_pollset_work(&g_pollset, &worker, gpr_now(GPR_CLOCK_MONOTONIC),
deadline);
}
GPR_ASSERT(state.read_bytes == state.target_read_bytes);
gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
gpr_slice_buffer_destroy(&state.incoming);
grpc_endpoint_destroy(ep);
}
/*
* main()
*/
int main (int argc, char **argv)
{
if (init_socket(&sockfd) < 0) {
printf("Init the socket failed.\n");
return -1;
}
/*
* Clean fd set.
*/
FD_ZERO(&active_fd_set);
FD_SET(sockfd, &active_fd_set);
max_fd = sockfd;
while (1) {
int err;
struct timeval tv;
fd_set read_fds; // Only use in current run.
/*
* Set select timeout.
*/
tv.tv_sec = 5;
tv.tv_usec = 0;
/*
* Copy fd set.
*/
read_fds = active_fd_set;
err = select(max_fd + 1, &read_fds, NULL, NULL, &tv);
if (err == -1) {
perror("select()");
return -1;
} else if (err == 0) {
printf("Select timeout\n");
continue;
} else {
/*
* Service all sockets.
*/
int i;
for (i = 0; i < FD_SETSIZE; i++) {
if (FD_ISSET(i, &read_fds)) {
if (i == sockfd) {
accept_cb();
} else {
read_cb(i);
}
}
} // end of for
} // end of if
} // end of while
return 0;
}
void event_cb( struct bufferevent *buf_ev, short events, void *arg )
{
if( events & BEV_EVENT_ERROR ) {
fprintf(stderr, "Ошибка объекта bufferevent.\n" );
bufferevent_free( buf_ev );
}
if( events & BEV_EVENT_EOF ) {
read_cb( buf_ev, arg );
bufferevent_free( buf_ev );
}
}
static _IO_ssize_t
_IO_cookie_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
{
struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
cookie_read_function_t *read_cb = cfile->__io_functions.read;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (read_cb);
#endif
if (read_cb == NULL)
return -1;
return read_cb (cfile->__cookie, buf, size);
}
void ws_connection::callback(async_fd & async) {
if (async.ready_read()) {
read_cb();
}
if (tcp_connection_.close_connection) {
VLOG(3) << "close_connection";
return;
}
if (async.ready_write()) {
write_cb();
}
}
void
purple_keyring_set_inuse(PurpleKeyring *newkeyring, gboolean force,
PurpleKeyringSetInUseCallback cb, gpointer data)
{
PurpleKeyring *oldkeyring;
PurpleKeyringChangeTracker *tracker;
GList *it;
PurpleKeyringRead read_cb;
if (current_change_tracker != NULL) {
GError *error;
purple_debug_error("keyring", "There is password migration "
"session already running.\n");
if (cb == NULL)
return;
error = g_error_new(PURPLE_KEYRING_ERROR,
PURPLE_KEYRING_ERROR_INTERNAL,
_("There is a password migration session already "
"running."));
cb(error, data);
g_error_free(error);
return;
}
oldkeyring = purple_keyring_get_inuse();
if (oldkeyring == newkeyring) {
if (purple_debug_is_verbose()) {
purple_debug_misc("keyring",
"Old and new keyring are the same: %s.\n",
(newkeyring != NULL) ?
newkeyring->id : "(null)");
}
if (cb != NULL)
cb(NULL, data);
return;
}
purple_debug_info("keyring", "Attempting to set new keyring: %s.\n",
(newkeyring != NULL) ? newkeyring->id : "(null)");
if (oldkeyring == NULL) { /* No keyring was set before. */
if (purple_debug_is_verbose()) {
purple_debug_misc("keyring", "Setting keyring for the "
"first time: %s.\n", newkeyring->id);
}
purple_keyring_inuse = newkeyring;
g_assert(current_change_tracker == NULL);
if (cb != NULL)
cb(NULL, data);
return;
}
/* Starting a migration. */
read_cb = purple_keyring_get_read_password(oldkeyring);
g_assert(read_cb != NULL);
purple_debug_misc("keyring", "Starting migration from: %s.\n",
oldkeyring->id);
tracker = g_new0(PurpleKeyringChangeTracker, 1);
current_change_tracker = tracker;
tracker->cb = cb;
tracker->cb_data = data;
tracker->new_kr = newkeyring;
tracker->old_kr = oldkeyring;
tracker->force = force;
for (it = purple_accounts_get_all(); it != NULL; it = it->next) {
if (tracker->abort) {
tracker->finished = TRUE;
break;
}
tracker->read_outstanding++;
if (it->next == NULL)
tracker->finished = TRUE;
read_cb(it->data, purple_keyring_set_inuse_read_cb, tracker);
}
}
//void udp_cb(EV_P_ ev_io *w, int revents) {
void udp_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
//printf("udp data:");
read_cb(loop, watcher, revents);
}
/*General read requests*/
void worker_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
printf(">%s on thread %d\n", __FUNCTION__, pthread_self());
//printf("I should do something!!");
//read_cb(loop, watcher, revents);
read_cb(loop, watcher, revents);
}
/*
* NET_Monitor
* Monitors the given sockets with the given timeout in milliseconds
* It ignores closed and loopback sockets.
* Calls the callback function read_cb(socket_t *) with the socket as parameter the socket when incoming data was detected on it
* Calls the callback function exception_cb(socket_t *) with the socket as parameter when a socket exception was detected on that socket
* For both callbacks, NULL can be passed. When NULL is passed for the exception_cb, no exception detection is performed
* Incoming data is always detected, even if the 'read_cb' callback was NULL.
*/
int NET_Monitor( int msec, socket_t *sockets[], void (*read_cb)(socket_t *, void*), void (*exception_cb)(socket_t *, void*), void *privatep[] )
{
struct timeval timeout;
fd_set fdsetr, fdsete;
fd_set *p_fdsete = NULL;
int i, ret;
int fdmax = 0;
if( !sockets || !sockets[0] )
return 0;
FD_ZERO( &fdsetr );
if (exception_cb) {
FD_ZERO( &fdsete );
p_fdsete = &fdsete;
}
for( i = 0; sockets[i]; i++ )
{
if (!sockets[i]->open)
continue;
switch( sockets[i]->type )
{
case SOCKET_UDP:
#ifdef TCP_SUPPORT
case SOCKET_TCP:
#endif
assert( sockets[i]->handle > 0 );
fdmax = max( (int)sockets[i]->handle, fdmax );
FD_SET( sockets[i]->handle, &fdsetr ); // network socket
if( p_fdsete )
FD_SET( sockets[i]->handle, p_fdsete );
break;
case SOCKET_LOOPBACK:
default:
continue;
}
}
timeout.tv_sec = msec / 1000;
timeout.tv_usec = ( msec % 1000 ) * 1000;
ret = select( fdmax+1, &fdsetr, NULL, p_fdsete, &timeout );
if ( ( ret > 0) && ( (read_cb) || (exception_cb)) ) {
// Launch callbacks
for( i = 0; sockets[i]; i++ ) {
if (!sockets[i]->open)
continue;
switch( sockets[i]->type ) {
case SOCKET_UDP:
#ifdef TCP_SUPPORT
case SOCKET_TCP:
#endif
if ( (exception_cb) && (p_fdsete) && (FD_ISSET(sockets[i]->handle, p_fdsete )) ) {
exception_cb(sockets[i], privatep ? privatep[i] : NULL);
}
if ( (read_cb) && (FD_ISSET(sockets[i]->handle, &fdsetr )) ) {
read_cb(sockets[i], privatep ? privatep[i] : NULL);
}
break;
case SOCKET_LOOPBACK:
default:
continue;
}
}
}
return ret;
}
int select_work(int listenfd)
{
int fdcount = 0;
int sock[FD_SETSIZE] = {0};
sock[fdcount++] = listenfd;
while(1)
{
fd_set read_set, write_set, error_set;
FD_ZERO(&read_set);
FD_ZERO(&write_set);
FD_ZERO(&error_set);
struct timeval tval;
tval.tv_sec = 0;
tval.tv_usec = 100 * 1000; // 100ms
int ready = 0;
int i = 0;
int nfds = 0;
for (i = 0; i < fdcount; i++)
{
if (sock[i] > 0)
{
FD_SET(sock[i], &read_set);
FD_SET(sock[i], &write_set);
FD_SET(sock[i], &error_set);
}
if (sock[i] > nfds)
{
nfds = sock[i];
}
}
ready = select(nfds + 1, &read_set, &write_set, &error_set, &tval);
if (ready < 0)
{
perror("select error");
return -1;
}
else if (ready == 0)
{
//printf("no select events\n");
usleep(100);
}
else
{
for (i = 0; i < fdcount; i++)
{
if (FD_ISSET(sock[i], &write_set) && sock[i] > 0)
{
if (write_cb(sock[i]) < 0)
{
sock[i] = 0;
}
}
if (FD_ISSET(sock[i], &read_set) && sock[i] > 0)
{
if (sock[i] == listenfd)
{
// accept events
struct sockaddr_in client_addr;
bzero(&client_addr, sizeof(client_addr));
socklen_t socklen = sizeof(struct sockaddr_in);
int fd = accept(listenfd, (struct sockaddr*)&client_addr, &socklen);
if (fd < 0)
{
perror("accept error");
return -1;
}
printf("accept client from[%s]\n", inet_ntoa(client_addr.sin_addr));
sock[fdcount++] = fd;
FD_SET(fd, &read_set);
}
else
{
if (read_cb(sock[i]) < 0)
{
sock[i] = 0;
}
}
}
}
}
}
return 0;
}
void
read_thunk(struct ev_io *w, int revents)
{
read_cb (w->fd, revents, w->data);
}
int main(int argc, char *argv[])
{
int free_parking_lots = PARKING_LOT_SIZE;
char *entrance_log,*exit_log; // Strings para log files
char msg_buffer[30];
char time_string[30];
/* Auxiliares */
int status; // Estatus de procedimientos
int i; // Iteraciones
int last_ticket; // Último ticket
struct msg *m; // Auxiliar para lectura de mensajes
pthread_t tid; // Thread para socket
if (argc != 7) {
printf ("Uso: sem_svr -l <puerto_sem_svr> -i <bitácora_entrada> -o <bitácora_salida> \n");
exit(0);
}
/* Port get for listening */
if (strcmp("-l",argv[1]) == 0 ) listen_port = atoi(argv[2]);
else if (strcmp("-l",argv[3]) == 0 ) listen_port = atoi(argv[4]);
else if (strcmp("-l",argv[5]) == 0 ) listen_port = atoi(argv[6]);
else {
perror("Error: No se ha especificado del puerto");
exit(0);
}
if (strcmp("-i",argv[1]) == 0 ) entrance_log = argv[2];
else if (strcmp("-i",argv[3]) == 0 ) entrance_log = argv[4];
else if (strcmp("-i",argv[5]) == 0 ) entrance_log = argv[6];
else {
perror("Error: No se ha especificado la bitacora de entrada");
exit(0);
}
if (strcmp("-o",argv[1]) == 0 ) exit_log = argv[2];
else if (strcmp("-o",argv[3]) == 0 ) exit_log = argv[4];
else if (strcmp("-o",argv[5]) == 0 ) exit_log = argv[6];
else {
perror("Error: No se ha especificado la bitacora de salida");
exit(0);
}
/* Initialize parking lot */
for (i = 0; i < PARKING_LOT_SIZE; ++i)
parking_space[i] = NULL;
/* initialize circular buffer for messages*/
init_buffer(&cb,(sizeof(struct msg)));
/* Iniciando hilo de socket de lectura */
pthread_create(&tid, NULL, read_messages, NULL);
pthread_detach(tid);
/* Ciclo indefinido de espera de mensajes, procesamiento y respuesta*/
while (1){
// Entrega de tickets y aceptar tickets de salida
while(free_parking_lots > 0 ) {
/* Esperar a el socket haya recibido alg'un mensaje */
while (its_empty(cb))
sleep(0.5);
/* Consumir mensaje */
m = read_cb(&cb);
if (m->in_out=='e')
{
last_ticket = new_ticket();
--free_parking_lots;
strftime(time_string
,30
,"%d%m%Y%H%M"
,parking_space[last_ticket]);
// formato BDDMMYYYYHHMMSSS con SSS como ticket serial
sprintf(msg_buffer,"1%s%03d",time_string,last_ticket);
write_action(entrance_log,WENT_IN,last_ticket);
answerClient(m->client.sin_addr,msg_buffer);
}
else if (m->in_out=='s' && parking_space[m->car_id] != NULL)
{
++free_parking_lots;
last_payment = ticket_price(m->car_id);
sprintf(msg_buffer,"X%d",last_payment);
answerClient(m->client.sin_addr,msg_buffer);
write_action(exit_log,WENT_OUT,m->car_id);
}
else if (m->in_out=='s' && parking_space[m->car_id] == NULL)
printf("Ese ticket no est'a en circulaci'on, intente de nuevo\n");
else printf("Accion inesperada\n");
}
/* Indicar que no hay puestos libres o aceptar ticket de salida */
while(free_parking_lots == 0)
{
while (its_empty(cb))
sleep(0.5);
m = read_cb(&cb);
if (m->in_out=='e') {
strftime(time_string
,20
,"%d%m%Y%H%M"
,parking_space[last_ticket]);
sprintf(msg_buffer,"0%sXXX",time_string);
answerClient(m->client.sin_addr,msg_buffer);
write_action(entrance_log,FULL,last_ticket);
}
else if (m->in_out=='s' && parking_space[m->car_id] != NULL){
++free_parking_lots;
last_payment = ticket_price(m->car_id);
sprintf(msg_buffer,"X%d",last_payment);
answerClient(m->client.sin_addr,msg_buffer);
write_action(exit_log,WENT_OUT,m->car_id);
}
else if (m->in_out=='s' && parking_space[m->car_id] == NULL)
printf("Ese ticket no est'a en circulaci'on, intente de nuevo\n");
else printf("Accion inesperada\n");
}
}
}
