/* Assigns a DP (uid) and its port to the given PCAP port. */
bool
pcap_drv_assign_dp_port(struct pcap_drv *drv, size_t drv_port_no, size_t dp_uid, of_port_no_t dp_port_no) {
pthread_rwlock_wrlock(drv->ports_rwlock);
if (drv->ports[drv_port_no] == NULL) {
pthread_rwlock_unlock(drv->ports_rwlock);
return false;
}
pthread_rwlock_unlock(drv->ports_rwlock);
struct pcap_port *pcap_port = drv->ports[drv_port_no];
pthread_rwlock_wrlock(pcap_port->rwlock);
if (pcap_port->dp_port_no != OF_NO_PORT) {
// dp port already assigned
pthread_rwlock_unlock(pcap_port->rwlock);
pthread_rwlock_unlock(drv->ports_rwlock);
return false;
}
pcap_port->dp_uid = dp_uid;
pcap_port->dp_port_no = dp_port_no;
pcap_port->of_port->port_no = dp_port_no;
pcap_port->of_stats->port_no = dp_port_no;
pcap_port->pkt_mbox = mbox_new(drv->loop, pcap_port, event_loop_pkt_out_cb);
ev_io_start(drv->loop, pcap_port->watcher);
pthread_rwlock_unlock(pcap_port->rwlock);
mbox_notify(drv->notifier); // needed for io watcher update on loop
return true;
}
/* Creates and spawns a new controller handler. */
struct ctrl * MALLOC_ATTR
ctrl_new(struct dp *dp) {
struct ctrl *ctrl = malloc(sizeof(struct ctrl));
ctrl->dp = dp;
ctrl->logger = logger_mgr_get(LOGGER_NAME_CTRL, dp_get_uid(dp));
struct ctrl_loop *ctrl_loop = malloc(sizeof(struct ctrl_loop));
ctrl_loop->dp = dp;
ctrl_loop->logger = logger_mgr_get(LOGGER_NAME_CTRL_IF, dp_get_uid(dp));
size_t i;
for (i=0; i<MAX_CONNS; i++) {
ctrl_loop->conns[i] = NULL;
}
ctrl_loop->conns_num = 1; // "0" is used for broadcast
ctrl->ctrl_loop = ctrl_loop;
ctrl_loop->ctrl = ctrl;
ctrl->thread = malloc(sizeof(pthread_t));
ctrl->loop = ev_loop_new(0/*flags*/);
ctrl_loop->loop = ctrl->loop;
ctrl->cmd_mbox = mbox_new(ctrl->loop, ctrl_loop, process_cmd);
ctrl->msg_mbox = mbox_new(ctrl->loop, ctrl_loop, process_msg);
ev_set_userdata(ctrl->loop, (void *)ctrl_loop);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
int rc;
if ((rc = pthread_create(ctrl->thread, &attr, event_loop, (void *)ctrl_loop)) != 0) {
logger_log(ctrl->logger, LOG_ERR, "Unable to create thread (%d).", rc);
//TODO free structures
return NULL;
}
logger_log(ctrl->logger, LOG_INFO, "Initialized.");
return ctrl;
}
void
config_add_mbox (struct config *config, char *filename)
{
struct mbox **p = &config->mailboxes;
while (*p) {
if (0 == strcmp ((*p)->filename, filename)) {
return;
}
p = &((*p)->next);
}
*p = mbox_new (config, filename);
}
struct packetproc*
packetproc_new(struct dp *dp) {
struct packetproc *packetproc = malloc(sizeof(struct packetproc));
packetproc->dp = dp;
packetproc->logger = logger_mgr_get(LOGGER_NAME_PP);
packetproc->pp_map = NULL;
packetproc->max_pp_num_global = MAX_PP_NUM_GLOBAL;
packetproc->current_pp_num_global = 0;
packetproc->pp_shared_data = NULL;
struct packetproc_loop *packetproc_loop = malloc(sizeof(struct packetproc_loop));
packetproc_loop->dp = dp;
packetproc_loop->logger = logger_mgr_get(LOGGER_NAME_PP_LOOP);
packetproc->packetproc_loop = packetproc_loop;
packetproc_loop->packetproc = packetproc;
packetproc->thread = malloc(sizeof(pthread_t));
packetproc->loop = ev_loop_new(0/*flags*/);
packetproc_loop->loop = packetproc->loop;
packetproc->msg_mbox = mbox_new(packetproc->loop, packetproc_loop, process_msg);
packetproc->mutex = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(packetproc->mutex, NULL);
/* Initialize basic packet processor structures and
* call #ppName#_packetproc_init for every pp type */
init_packetprocessors(packetproc);
ev_set_userdata(packetproc->loop, (void *)packetproc_loop);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
int rc;
if ((rc = pthread_create(packetproc->thread, &attr, event_loop, (void *)packetproc_loop)) != 0) {
logger_log(packetproc->logger, LOG_ERR, "Unable to create thread (%d).", rc);
//TODO free structures
return NULL;
}
logger_log(packetproc->logger, LOG_INFO, "Initialized.");
return packetproc;
}
/* Static initializer for the driver. */
struct pcap_drv * MALLOC_ATTR
pcap_drv_init(struct port_drv *drv) {
struct pcap_drv *pcap_drv = malloc(sizeof(struct pcap_drv));
pcap_drv->drv = drv;
pcap_drv->logger = logger_mgr_get(LOGGER_NAME_PORT_DRV_PCAP);
pcap_drv->ports_map = NULL;
size_t i;
for (i=0; i<MAX_PORTS; i++) {
pcap_drv->ports[i] = NULL;
}
pcap_drv->ports_num = 0;
pcap_drv->ports_rwlock = malloc(sizeof(pthread_rwlock_t));
pthread_rwlock_init(pcap_drv->ports_rwlock, NULL);
struct pcap_drv_loop *pcap_drv_loop = malloc(sizeof(struct pcap_drv_loop));
pcap_drv_loop->logger = logger_mgr_get(LOGGER_NAME_PORT_DRV_PCAP_IF);
pcap_drv->pcap_drv_loop = pcap_drv_loop;
pcap_drv_loop->pcap_drv = pcap_drv;
pcap_drv->thread = malloc(sizeof(pthread_t));
pcap_drv->loop = ev_loop_new(0/*flags*/);
pcap_drv_loop->loop = pcap_drv->loop;
ev_set_userdata(pcap_drv->loop, (void *)pcap_drv_loop);
pcap_drv->notifier = mbox_new(pcap_drv->loop, NULL, NULL);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
int rc;
if ((rc = pthread_create(pcap_drv->thread, &attr, event_loop, (void *)pcap_drv_loop)) != 0) {
logger_log(pcap_drv->logger, LOG_ERR, "Unable to create thread (%d).", rc);
//TODO: free structures
return NULL;
}
logger_log(pcap_drv->logger, LOG_INFO, "PCAP initialized.");
return pcap_drv;
}
int main (int argc, char **argv)
{
mbox_err_t err;
mbox_t *mbox;
mbox_mail_t *mail;
assert(argc > 1);
err = mbox_new(argv[1], &mbox);
if (err) {
fprintf(stderr, "Mbox error: %s\n", mbox_strerr(err));
exit(1);
}
printf("Starting to get milk\n");
while ((mail = mbox_next_mail (mbox)) != NULL) {
const dlist_t *trace;
diter_t *iter;
printf("Is to [%s]\n", mbox_mail_getattr(mail, "To"));
printf("Mail trace:\n");
trace = mbox_mail_gettrace(mail);
iter = dlist_iter_new((dlist_t **)&trace);
while (diter_hasnext(iter)) {
printf("\t%s\n", (char *)diter_next(iter));
}
dlist_iter_free(iter);
printf("FOLLOWING TEXT\n");
printf("%s\n", mbox_mail_getbody(mail));
printf("END OF TEXT\n");
mbox_mail_free(mail);
}
printf("LOL WUT?\n");
mbox_free(mbox);
exit(0);
}
