static void rb_ssl_tryaccept(rb_fde_t *F, void *data) { int ret; struct acceptdata *ad; lrb_assert(F->accept != NULL); ret = do_ssl_handshake(F, rb_ssl_tryaccept, NULL); /* do_ssl_handshake does the rb_setselect */ if(ret == 0) return; ad = F->accept; F->accept = NULL; rb_settimeout(F, 0, NULL, NULL); rb_setselect(F, RB_SELECT_READ | RB_SELECT_WRITE, NULL, NULL); if(ret > 0) ad->callback(F, RB_OK, (struct sockaddr *)&ad->S, ad->addrlen, ad->data); else ad->callback(F, RB_ERROR_SSL, NULL, 0, ad->data); rb_free(ad); }
void free_listener(struct Listener *listener) { s_assert(NULL != listener); if(listener == NULL) return; /* * remove from listener list */ if(listener == ListenerPollList) ListenerPollList = listener->next; else { struct Listener *prev = ListenerPollList; for (; prev; prev = prev->next) { if(listener == prev->next) { prev->next = listener->next; break; } } } /* free */ rb_free(listener); }
/* mr_user() * parv[1] = username (login name, account) * parv[2] = client host name (ignored) * parv[3] = server host name (ignored) * parv[4] = users gecos */ static int mr_user(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]) { static char buf[BUFSIZE]; char *p; if (strlen(client_p->id) == 3) { exit_client(client_p, client_p, client_p, "Mixing client and server protocol"); return 0; } if(source_p->flags & FLAGS_SENTUSER) return 0; if((p = strchr(parv[1], '@'))) *p = '\0'; rb_snprintf(buf, sizeof(buf), "%s %s", parv[2], parv[3]); rb_free(source_p->localClient->fullcaps); source_p->localClient->fullcaps = rb_strdup(buf); do_local_user(client_p, source_p, parv[1], parv[4]); return 0; }
/* * mr_capab - CAPAB message handler * parv[1] = space-separated list of capabilities * */ static int mr_capab(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]) { struct Capability *cap; int i; char *p; char *s; /* ummm, this shouldn't happen. Could argue this should be logged etc. */ if (client_p->localClient == NULL) return 0; if (client_p->user) return 0; /* CAP_TS6 is set in PASS, so is valid.. */ if ((client_p->localClient->caps & ~CAP_TS6) != 0) { exit_client(client_p, client_p, client_p, "CAPAB received twice"); return 0; } else client_p->localClient->caps |= CAP_CAP; rb_free(client_p->localClient->fullcaps); client_p->localClient->fullcaps = rb_strdup(parv[1]); for (i = 1; i < parc; i++) { char *t = LOCAL_COPY(parv[i]); for (s = rb_strtok_r(t, " ", &p); s; s = rb_strtok_r(NULL, " ", &p)) { for (cap = captab; cap->name; cap++) { if (!irccmp(cap->name, s)) { client_p->localClient->caps |= cap->cap; break; } } } } return 0; }
static int me_gcap(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]) { struct Capability *cap; char *t = LOCAL_COPY(parv[1]); char *s; char *p; if (!IsServer(source_p)) return 0; /* already had GCAPAB?! */ if (!EmptyString(source_p->serv->fullcaps)) { source_p->serv->caps = 0; rb_free(source_p->serv->fullcaps); } source_p->serv->fullcaps = rb_strdup(parv[1]); for (s = rb_strtok_r(t, " ", &p); s; s = rb_strtok_r(NULL, " ", &p)) { for (cap = captab; cap->name; cap++) { if (!irccmp(cap->name, s)) { source_p->serv->caps |= cap->cap; break; } } } return 0; }
void rb_ssl_accept_setup(rb_fde_t *F, rb_fde_t *new_F, struct sockaddr *st, int addrlen) { new_F->type |= RB_FD_SSL; new_F->ssl = rb_malloc(sizeof(gnutls_session_t)); new_F->accept = rb_malloc(sizeof(struct acceptdata)); new_F->accept->callback = F->accept->callback; new_F->accept->data = F->accept->data; rb_settimeout(new_F, 10, rb_ssl_timeout, NULL); memcpy(&new_F->accept->S, st, addrlen); new_F->accept->addrlen = addrlen; gnutls_init((gnutls_session_t *) new_F->ssl, GNUTLS_SERVER); gnutls_set_default_priority(SSL_P(new_F)); gnutls_credentials_set(SSL_P(new_F), GNUTLS_CRD_CERTIFICATE, x509); gnutls_dh_set_prime_bits(SSL_P(new_F), 1024); gnutls_transport_set_ptr(SSL_P(new_F), (gnutls_transport_ptr_t) (long int)rb_get_fd(new_F)); gnutls_certificate_server_set_request(SSL_P(new_F), GNUTLS_CERT_REQUEST); gnutls_priority_set(SSL_P(F), default_priority); if(do_ssl_handshake(F, rb_ssl_tryaccept, NULL)) { struct acceptdata *ad = F->accept; F->accept = NULL; ad->callback(F, RB_OK, (struct sockaddr *)&ad->S, ad->addrlen, ad->data); rb_free(ad); } }
void rb_ssl_start_accepted(rb_fde_t *new_F, ACCB * cb, void *data, int timeout) { gnutls_session_t *ssl; new_F->type |= RB_FD_SSL; ssl = new_F->ssl = rb_malloc(sizeof(gnutls_session_t)); new_F->accept = rb_malloc(sizeof(struct acceptdata)); new_F->accept->callback = cb; new_F->accept->data = data; rb_settimeout(new_F, timeout, rb_ssl_timeout, NULL); new_F->accept->addrlen = 0; gnutls_init(ssl, GNUTLS_SERVER); gnutls_set_default_priority(*ssl); gnutls_credentials_set(*ssl, GNUTLS_CRD_CERTIFICATE, x509); gnutls_dh_set_prime_bits(*ssl, 1024); gnutls_transport_set_ptr(*ssl, (gnutls_transport_ptr_t) (long int)new_F->fd); gnutls_certificate_server_set_request(*ssl, GNUTLS_CERT_REQUEST); gnutls_priority_set(*ssl, default_priority); if(do_ssl_handshake(new_F, rb_ssl_tryaccept, NULL)) { struct acceptdata *ad = new_F->accept; new_F->accept = NULL; ad->callback(new_F, RB_OK, (struct sockaddr *)&ad->S, ad->addrlen, ad->data); rb_free(ad); } }
void operhash_delete(const char *name) { struct operhash_entry *ohash = irc_radixtree_retrieve(operhash_tree, name); if (ohash != NULL) rb_free(ohash); }
void vorbis_decoder_close(decoder_t * dec) { vorbis_pdata_t * pd = (vorbis_pdata_t *)dec->pdata; ov_clear(&(pd->vf)); rb_free(pd->rb); }
static void rb_ssl_connect_realcb(rb_fde_t *F, int status, struct ssl_connect *sconn) { F->connect->callback = sconn->callback; F->connect->data = sconn->data; rb_free(sconn); rb_connect_callback(F, status); }
static void do_modload(struct Client *source_p, const char *module) { char *m_bn = rb_basename(module); int origin; if(findmodule_byname(m_bn) != -1) { sendto_one_notice(source_p, ":Module %s is already loaded", m_bn); rb_free(m_bn); return; } origin = strcmp(module, m_bn) == 0 ? MAPI_ORIGIN_CORE : MAPI_ORIGIN_EXTENSION; load_one_module(module, origin, false); rb_free(m_bn); }
void rb_sigio_unsched_event(struct ev_entry *event) { if(can_do_event <= 0) return; timer_delete(*((timer_t *) event->comm_ptr)); rb_free(event->comm_ptr); event->comm_ptr = NULL; }
static int generate_challenge(char **r_challenge, char **r_response, RSA * rsa) { SHA_CTX ctx; unsigned char secret[CHALLENGE_SECRET_LENGTH], *tmp; unsigned long length; unsigned long e = 0; unsigned long cnt = 0; int ret; if(!rsa) return -1; if(rb_get_random(secret, CHALLENGE_SECRET_LENGTH)) { SHA1_Init(&ctx); SHA1_Update(&ctx, (uint8_t *)secret, CHALLENGE_SECRET_LENGTH); *r_response = malloc(SHA_DIGEST_LENGTH); SHA1_Final((uint8_t *)*r_response, &ctx); length = RSA_size(rsa); tmp = rb_malloc(length); ret = RSA_public_encrypt(CHALLENGE_SECRET_LENGTH, secret, tmp, rsa, RSA_PKCS1_OAEP_PADDING); if(ret >= 0) { *r_challenge = (char *)rb_base64_encode(tmp, ret); rb_free(tmp); return 0; } rb_free(tmp); rb_free(*r_response); *r_response = NULL; } ERR_load_crypto_strings(); while ((cnt < 100) && (e = ERR_get_error())) { ilog(L_MAIN, "SSL error: %s", ERR_error_string(e, 0)); cnt++; } return (-1); }
void speex_dec_close(decoder_t * dec) { speex_pdata_t * pd = (speex_pdata_t *)dec->pdata; oggz_close(pd->oggz); speex_bits_destroy(&(pd->bits)); speex_decoder_destroy(pd->decoder); rb_free(pd->rb); }
void rb_helper_close(rb_helper *helper) { if(helper == NULL) return; rb_kill(helper->pid, SIGKILL); rb_close(helper->ifd); rb_close(helper->ofd); rb_free(helper); }
/* * Destroy all the elements blow us in the tree * only useful as part of a complete tree destroy. */ static void rb_destroy(struct rbnode *x,void (*free_function)(void *)) { if (x!=RBNULL) { if (x->left!=RBNULL) rb_destroy(x->left,free_function); if (x->right!=RBNULL) rb_destroy(x->right,free_function); if (free_function!=NULL) free_function(x->object); rb_free(x); } }
void my_cat(int fd) { char *str; while (str = get_line(fd)) { my_putstr(str); my_putchar('\n'); rb_free(str); } }
/* ** me_certfp ** parv[1] = certfp string */ static int me_certfp(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[]) { if (!IsPerson(source_p)) return 0; rb_free(source_p->certfp); source_p->certfp = NULL; if (!EmptyString(parv[1])) source_p->certfp = rb_strdup(parv[1]); return 0; }
/* * safelist_client_release() * * inputs - pointer to Client being listed on * outputs - none * side effects - the client is no longer being * listed * * Please do not ever call this on a non-local client. * If you do, you will get SIGSEGV. */ static void safelist_client_release(struct Client *client_p) { s_assert(MyClient(client_p)); rb_dlinkFindDestroy(client_p, &safelisting_clients); rb_free(client_p->localClient->safelist_data); client_p->localClient->safelist_data = NULL; sendto_one(client_p, form_str(RPL_LISTEND), me.name, client_p->name); }
void rb_ssl_ctx_free(rb_ssl_ctx *sctx) { if(sctx == NULL) return; sctx->refcount--; if(sctx->refcount == 0) { SSL_CTX_free(sctx->ssl_ctx); rb_free(sctx); } }
void ring_example() { rb_ringbuffer * buffer; uint64_t seq_num = 0; char * entry; rb_init(&buffer, 4, 1024); rb_claim(buffer, &seq_num, 1); rb_get(buffer, &entry, seq_num); rb_publish(buffer, seq_num, 1); rb_release(buffer, seq_num, 1); rb_free(&buffer); }
static void submit_dns_answer(const char *reply, bool status, query_type type, void *data) { char *id = data; if(!id || type == QUERY_INVALID) { warn_opers(L_CRIT, "DNS: submit_dns_answer gave us a bad query"); exit(EX_DNS_ERROR); } if(reply == NULL || status == false) { rb_helper_write(authd_helper, "E %s E %c *", id, type); rb_free(id); return; } rb_helper_write(authd_helper, "E %s O %c %s", id, type, reply); rb_free(id); }
/*! * \brief Wait for activity on an socket * \param fd -- file descriptor * \param ms -- pointer to an int containing a timeout in ms * \return 0 on timeout and the socket fd (non-zero) otherwise * \retval 0 timeout */ EXPORT_DEF int at_wait (int fd, int* ms) { int exception, outfd; outfd = ast_waitfor_n_fd (&fd, 1, ms, &exception); if (outfd < 0) { outfd = 0; } return outfd; } #/* return number of bytes readed */ EXPORT_DEF ssize_t at_read (int fd, const char * dev, struct ringbuffer* rb) { struct iovec iov[2]; int iovcnt; ssize_t n = -1; /* TODO: read until major error */ iovcnt = rb_write_iov (rb, iov); if (iovcnt > 0) { n = readv (fd, iov, iovcnt); if (n < 0) { if (errno != EINTR && errno != EAGAIN) { ast_debug (1, "[%s] readv() error: %d\n", dev, errno); return n; } return 0; } else if (n > 0) { rb_write_upd (rb, n); ast_debug (5, "[%s] receive %zu byte, used %zu, free %zu, read %zu, write %zu\n", dev, n, rb_used (rb), rb_free (rb), rb->read, rb->write); iovcnt = rb_read_all_iov (rb, iov); if (iovcnt > 0) { if (iovcnt == 2) { ast_debug (5, "[%s] [%.*s%.*s]\n", dev, (int) iov[0].iov_len, (char*) iov[0].iov_base, (int) iov[1].iov_len, (char*) iov[1].iov_base); } else { ast_debug (5, "[%s] [%.*s]\n", dev, (int) iov[0].iov_len, (char*) iov[0].iov_base); } } } } else ast_log (LOG_ERROR, "[%s] at cmd receive buffer overflow\n", dev); return n; }
void rb_ssl_ctx_free(rb_ssl_ctx *sctx) { if(sctx == NULL) return; sctx->refcount--; if(sctx->refcount == 0) { /* XXX mbedtls_ctx_free??? */ // SSL_CTX_free(sctx->ssl_ctx); rb_free(sctx); } }
static void parse_windows_resolvers(void) { const char *ns = get_windows_nameservers(); char *server; char *p; char *buf = rb_strdup(ns); for(server = rb_strtok_r(buf, " ", &p); server != NULL;server = rb_strtok_r(NULL, " ", &p)) { add_nameserver(server); } rb_free(buf); }
void rb_dispose_sample_struct_array(sample_struct_array_t * obj_val) { if (!obj_val || !obj_val->arr) { return; } rb_size_t i = 0; for (i = 0; i < obj_val->size; ++i) { rb_dispose_sample_struct(obj_val->arr + i); } rb_free(obj_val->arr); memset(obj_val, 0, sizeof(sample_struct_array_t)); }
void rb_ssl_shutdown(rb_fde_t *F) { int i; if (F == NULL || F->ssl == NULL) return; for (i = 0; i < 4; i++) { if (gnutls_bye(SSL_P(F), GNUTLS_SHUT_RDWR) == GNUTLS_E_SUCCESS) break; } gnutls_deinit(SSL_P(F)); rb_free(F->ssl); }
void rb_ssl_shutdown(rb_fde_t *F) { int i; if(F == NULL || F->ssl == NULL) return; for(i = 0; i < 4; i++) { int r = mbedtls_ssl_close_notify(SSL_P(F)); if(r != MBEDTLS_ERR_SSL_WANT_READ && r != MBEDTLS_ERR_SSL_WANT_WRITE) break; } mbedtls_ssl_free(SSL_P(F)); rb_free(F->ssl); }
void rb_epoll_unsched_event(struct ev_entry *event) { #ifdef USE_TIMERFD_CREATE if(can_do_timerfd) { rb_close((rb_fde_t *)event->comm_ptr); event->comm_ptr = NULL; return; } #endif timer_delete(*((timer_t *) event->comm_ptr)); rb_free(event->comm_ptr); event->comm_ptr = NULL; }
void cdda_scanner_stop(void) { cdda_scanner_working = 0; AQUALUNG_THREAD_JOIN(cdda_scanner_id) cdda_timeout_callback(NULL); /* cleanup any leftover messages */ cdda_timeout_stop(); #ifdef _WIN32 g_mutex_free(cdda_mutex); #endif /* _WIN32 */ rb_free(cdda_notify_rb); }