static int cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
{
int ret = 0;
switch (event->event) {
case RDMA_CM_EVENT_ADDR_RESOLVED:
ret = addr_handler(cma_id->context);
break;
case RDMA_CM_EVENT_ROUTE_RESOLVED:
ret = route_handler(cma_id->context);
break;
case RDMA_CM_EVENT_CONNECT_REQUEST:
ret = connect_handler(cma_id);
break;
case RDMA_CM_EVENT_ESTABLISHED:
ret = resolved_handler(cma_id->context, event);
break;
case RDMA_CM_EVENT_ADDR_ERROR:
case RDMA_CM_EVENT_ROUTE_ERROR:
case RDMA_CM_EVENT_CONNECT_ERROR:
case RDMA_CM_EVENT_UNREACHABLE:
case RDMA_CM_EVENT_REJECTED:
printf("udaddy: event: %s, error: %d\n",
rdma_event_str(event->event), event->status);
connect_error();
ret = event->status;
break;
case RDMA_CM_EVENT_DEVICE_REMOVAL:
/* Cleanup will occur after test completes. */
break;
default:
break;
}
return ret;
}
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
int (*connect_handler)(int, const struct sockaddr*, socklen_t);
struct sockaddr_in* saddr = (struct sockaddr_in*)addr;
int size = 156;
char dest[size];
unsigned short port = ntohs(saddr->sin_port);
inet_ntop(AF_INET, &(saddr)->sin_addr.s_addr, dest, size);
fprintf(stderr, "[connect to %s:%u]\n", dest, port);
connect_handler = dlsym(RTLD_NEXT, "connect");
return connect_handler(sockfd, addr, addrlen);
}
static gboolean
key_press_func(GtkWidget* widget, GdkEventKey* key, gpointer data)
{
#define KEY_ENTER 0xff0d
#define KEY_ESC 0xff1b
struct entry_win *c = data;
if (KEY_ENTER == key->keyval) {
connect_handler(GTK_BUTTON(c->connect_button), c);
return TRUE;
} else if (KEY_ESC == key->keyval) {
c->connected = FALSE;
gtk_main_quit();
return TRUE;
}
return FALSE;
#undef KEY_ENTER
#undef KEY_ESC
}
void* eventloop(void* socket) {
Msg msg;
while (1) {
msg_recv(socket, &msg);
switch (msg.header.msg_type) {
case msg_execute_request:
execute_handler(socket, &msg);
break;
case msg_complete_request:
complete_handler(socket, &msg);
break;
case msg_kernel_info_request:
kernel_info_handler(socket, &msg);
break;
case msg_connect_request:
connect_handler(socket, &msg);
break;
case msg_shutdown_request:
shutdown_handler(socket, &msg);
break;
case msg_object_info_request:
object_info_handler(socket, &msg);
break;
case msg_history_request:
history_handler(socket, &msg);
break;
default:
fprintf(stderr, "error: unsupported message type: %s", dump_msg_type(msg.header.msg_type));
exit(1);
}
}
pthread_exit(NULL);
return NULL;
}
(void)available1;
std::size_t available2 = socket1.available(ec);
(void)available2;
socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0));
socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0));
socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0), ec);
socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0), ec);
socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0));
socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0));
socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0), ec);
socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0), ec);
socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0),
connect_handler());
socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0),
connect_handler());
int i1 = socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), lazy);
(void)i1;
int i2 = socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), lazy);
(void)i2;
socket1.set_option(settable_socket_option1);
socket1.set_option(settable_socket_option1, ec);
socket1.set_option(settable_socket_option2);
socket1.set_option(settable_socket_option2, ec);
socket1.set_option(settable_socket_option3);
socket1.set_option(settable_socket_option3, ec);
socket1.get_option(gettable_socket_option1);
servers_widget::servers_widget(QWidget *parent) :
QWidget(parent),
m_smodel(NULL),
m_connect_menu(NULL),
m_connect_action(NULL),
m_remove_action(NULL),
m_remove_all_action(NULL),
last_server_name(""),
last_server_port(0)
{
setupUi(this);
// prepare menus
m_connect_menu = new QMenu(this);
m_connect_action = new QAction(this);
m_connect_action->setText(tr("Connect to"));
m_connect_action->setIcon(QIcon(":/emule/common/ConnectDo.ico"));
m_remove_action = new QAction(this);
m_remove_action->setText(tr("Remove"));
m_remove_action->setIcon(QIcon(":/emule/common/DeleteSelected.ico"));
m_remove_all_action = new QAction(this);
m_remove_all_action->setText(tr("Remove all"));
m_remove_all_action->setIcon(QIcon(":/emule/common/DeleteAll.ico"));
m_connect_menu->addAction(m_connect_action);
m_connect_menu->addSeparator();
m_connect_menu->addAction(m_remove_action);
m_connect_menu->addAction(m_remove_all_action);
connect(m_connect_action, SIGNAL(triggered()), this, SLOT(connect_handler()));
connect(m_remove_action, SIGNAL(triggered()), this, SLOT(remove_handler()));
connect(m_remove_all_action, SIGNAL(triggered()), this, SLOT(removeAll_handler()));
m_smodel = new servers_table_model(this);
m_smodel->load();
m_sort_model = new QSortFilterProxyModel(this);
m_sort_model->setSourceModel(m_smodel);
tableServers->setModel(m_sort_model);
Preferences pref;
if (!hsplit->restoreState(pref.value("ServersWidget/HSplitter").toByteArray()))
{
QList<int> sz;
sz << 500 << 100;
hsplit->setSizes(sz);
}
tableServers->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
vsplit->restoreState(pref.value("ServersWidget/VSplitter").toByteArray());
tableServers->horizontalHeader()->restoreState(pref.value("ServersWidget/TableServers").toByteArray());
connect(tableServers->horizontalHeader(), SIGNAL(sortIndicatorChanged(int, Qt::SortOrder)),
this, SLOT(serversSortChanged(int, Qt::SortOrder)));
connect(tableServers->horizontalHeader(), SIGNAL(customContextMenuRequested(const QPoint&)),
this, SLOT(displayHeaderMenu(const QPoint&)));
connect(tableServers, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayPopupMenu(const QPoint&)));
tableServers->horizontalHeader()->setSortIndicator(servers_table_model::DC_NAME, Qt::AscendingOrder);
}
