rt_public void wide_listen(void)
{
/* Listen on all the file descriptors opened for reading until the
* connected socket is broken.
*/
/* Make sure we listen on the connected socket and call the handling
* routine whenever data is available there.
*/
#ifdef EIF_WINDOWS
if (-1 == add_input(app_sp, (STREAM_FN) arqsthandle)) {
#else
if (-1 == add_input(app_sp, arqsthandle)) {
#endif
#ifdef USE_ADD_LOG
add_log(4, "add_input: %s (%s)", s_strerror(), s_strname());
#endif
dexit(1);
}
#ifdef USE_ADD_LOG
add_log(12, "in listen");
#endif
/* After having selected, we scan all our files to make sure none of them
* has been removed from the selection process. If at least one is missing,
* we are exiting immediately.
*/
#ifdef EIF_WINDOWS
while (0 <= do_select(0)) {
#ifdef USE_ADD_LOG
add_log(12, "in while do_select");
#endif
if (!has_input(app_sp)) { /* Socket connection broken? */
#ifdef USE_ADD_LOG
add_log(12, "in !has_input which is what we want");
#endif
return; /* Anyway, abort processing */
}
}
#ifdef USE_ADD_LOG
add_log(12, "out of listen");
#endif
#else
while (0 < do_select((struct timeval *) 0)) {
if (!has_input(app_sp)) /* Socket connection broken? */
return; /* Anyway, abort processing */
}
#endif
#ifdef USE_ADD_LOG
add_log(12, "do_select: %s (%s)", s_strerror(), s_strname());
#endif
}
int main(int ac, char **av)
{
t_main c;
int res;
c.connect = FALSE;
c.m = init_gtk(&ac, &av);
c.start = 0;
c.end = 0;
while (1)
{
if (c.connect == TRUE)
do_select(&c);
gtk_main_iteration();
if (!c.m->buffer)
continue;
c.tab = str_to_wordtab((char *)c.m->buffer);
if ((res = gere_cmd(&c)) == -1)
aff_msg(c.m, "Usage: /server host[:port]\n");
else if (!res)
send_serv(c.m, c.m->buffer, c.sfd);
gtk_widget_show_all(c.m->main_win);
free_tab(c.tab);
c.m->buffer = xfree(c.m->buffer);
}
return (EXIT_SUCCESS);
}
int main()
{
int msock, sel;
char *service = "ftp";
enum selection option;
printf("Please enter number to select corresponding option:\n");
printf("0: select\n1:fork\n2:thread\n");
scanf("%d", &sel);
option = sel;
msock = passiveTCP(service, QLEN);
switch(option)
{
case SELECT:
printf("SELECT option was selected\n");
do_select(msock);
break;
case FORK:
printf("FORK option was selected\n");
do_fork(msock);
break;
case THREAD:
printf("THREAD option was selected\n");
do_thread(msock);
break;
default:
printf("Invalid option\n");
exit(1);
}
}
int main(int argc, char**argv)
{
char*sites[] = { "www.alongsoft.com","www.baidu.com", "www.renren.com:80", "www.google.com",
"www.weibo.com", "www.126.com", "www.163.com/index.html" };
int test_count = sizeof(sites) / sizeof(char*);
int* sockfds = (int*) memory_malloc(sizeof(int) * test_count);
int i = 0;
for (; i < test_count; ++i)
{
if ((sockfds[i] = request(sites[i])) < 0)
{
ERROR("request %s error!\n",sites[i]);
free(sockfds);
return -1;
}
}
if (do_select(sockfds, test_count) != 0)
{
ERROR("select deal error\n");
return -1;
}
//关闭
for (i = 0; i < test_count; ++i)
{
close(sockfds[i]);
}
return 0;
}
void mloop()
{
fd_set rfds;
fd_set wfds;
while(loop_flag){
FD_ZERO(&rfds);
FD_ZERO(&wfds);
rfdset(moption.mcsocket, &rfds);
wfdset(moption.mcsocket, &wfds);
cfdset(moption.comm, &rfds, &wfds);
if(do_select(&rfds, &wfds)){
do_pong();
do_free();
}else{
do_pong();
do_recv();
do_send();
do_accept(moption.comm, &rfds);
do_comexe(moption.comm, &rfds);
do_exechk(moption.comm);
}
if(log_level != moption.loglevel){
lprintf(0, "%s: loglevel change %d to %d\n", __func__, moption.loglevel, log_level);
moption.loglevel = log_level;
}
}
}
static void client(int sock, const char *name)
{
char buff[BUF_SIZE + 1];
fd_set rdfs;
write_server(sock, name);
while (42)
{
do_select(sock, &rdfs);
if (FD_ISSET(STDIN_FILENO, &rdfs))
{
read_msg(buff);
write_server(sock, buff);
}
else if (FD_ISSET(sock, &rdfs))
{
if (read_server(sock, buff) == 0)
{
printf("Server disconnected !\n");
break ;
}
ft_putendl(buff);
if (ft_strcmp(buff, "Pseudo already used") == 0)
write_server(sock, pseudo());
}
}
close(sock);
}
void HTMLButcherListEditDialog::OnSelect(wxCommandEvent& event)
{
wxListBox *lb = (wxListBox*) FindWindow(ID_ITEMS);
if (lb->GetSelection() != wxNOT_FOUND) {
do_select(static_cast<ButcherListIdClientData*>(lb->GetClientObject(lb->GetSelection()))->GetId());
}
}
void main_loop(t_env *e)
{
while (42)
{
init_fd(e);
do_select(e);
check_fd(e);
}
}
int main(int argc, char *argv[])
{
int listenfd;
listenfd = socket_bind(IPADDRESS, PORT);
listen(listenfd, LISTENQ);
do_select(listenfd);
return EXIT_SUCCESS;
}
int main(int argc,char *argv[])
{
int listenfd,connfd,sockfd;
struct sockaddr_in cliaddr;
socklen_t cliaddrlen;
listenfd = socket_bind(IPADDRESS,PORT);
listen(listenfd,LISTENQ);
do_select(listenfd);
return 0;
}
int main(int argc, const char *argv[])
{
if(signal(SIGPIPE, SIG_IGN) == SIG_ERR)
ERR_EXIT("signal");
int fd_server;
preprocess(&fd_server);
do_select(fd_server);
close(fd_server);
return 0;
}
bool GSISocketServer::Peek(int bufsize, std::string& s)
{
if (!ssl) {
SetError("No connection established");
return false;
}
ERR_clear_error();
int ret = -1, ret2 = -1;
char *buffer = (char *)OPENSSL_malloc(bufsize);
int fd = BIO_get_fd(SSL_get_rbio(ssl), NULL);
time_t starttime, curtime;
int error = 0;
int expected = 0;
starttime = time(NULL);
do {
ret = do_select(fd, starttime, timeout, expected);
curtime = time(NULL);
if (ret > 0) {
ret2 = SSL_peek(ssl, buffer, bufsize);
if (ret2 <= 0)
expected = error = SSL_get_error(ssl, ret2);
}
} while ((ret > 0) &&
((ret2 <= 0) &&
(((timeout == -1) ||
((timeout != -1) &&
(curtime - starttime < timeout))) &&
((error == SSL_ERROR_WANT_READ) ||
(error == SSL_ERROR_WANT_WRITE)))));
if (ret <= 0 || ret2 <= 0) {
if (timeout != -1 && (curtime - starttime >= timeout))
SetError("Connection stuck during read: timeout reached.");
else
SetErrorOpenSSL("Error during SSL read:");
OPENSSL_free(buffer);
ERR_clear_error();
return false;
}
s = std::string(buffer, ret2);
OPENSSL_free(buffer);
ERR_clear_error();
return true;
}
void server_loop(t_env *e)
{
printf("port : %d\n", e->port);
printf("sockfd : %d\n", e->sockfd);
while (1)
{
init_fd(e);
do_select(e);
check_fd(e);
}
}
void game(t_env *env)
{
while (stop == 42)
{
init_fds(env);
do_select(env);
check_fds(env);
apply_timers(env);
do_actions(env);
}
}
int
__select(int n,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
struct timeval *timeout)
{
check_init("__select");
return do_select(n, readfds, writefds, exceptfds,
timeout, smbw_libc.__select);
}
int main(int argc, const char *argv[])
{
if(signal(SIGPIPE, SIG_IGN) == SIG_ERR)
ERR_EXIT("signal");
int listenfd = get_listen_fd();
do_select(listenfd);
close(listenfd);
return 0;
}
int main(int argc,char *argv[])
{
int listenfd,connfd,sockfd;
//os_memset(&server1_select, 0, sizeof(server1_select));
//dl_list_init(&server1_select.timeout);
//select_register_timeout(5,0,demon_server1_timeout,NULL,NULL);
struct sockaddr_in cliaddr;
socklen_t cliaddrlen;
listenfd = socket_bind(IPADDRESS,PORT);
listen(listenfd,LISTENQ);
do_select(listenfd);
return 0;
}
void FieldStringEditor::press(const Event& event) {
Event e;
display->Draw(output, canvas);
switch (event.pointer_button()) {
case Event::left:
do_select(e);
break;
case Event::middle:
do_grab_scroll(e);
break;
case Event::right:
do_rate_scroll(e);
break;
}
}
static void
rb_thread_wait_fd_rw(int fd, int read)
{
int result = 0;
while (result <= 0) {
rb_fdset_t *set = ALLOC(rb_fdset_t);
rb_fd_init(set);
FD_SET(fd, set);
if (read) {
result = do_select(fd + 1, rb_fd_ptr(set), 0, 0, 0);
}
else {
result = do_select(fd + 1, 0, rb_fd_ptr(set), 0, 0);
}
rb_fd_term(set);
if (result < 0) {
rb_sys_fail(0);
}
}
}
void main_loop(t_env *e)
{
int i;
i = 0;
while (1)
{
i = 0;
while (i < e->nbteam)
i++;
init_fd(e);
do_select(e);
check_fd(e);
serv_update(e);
}
}
static void sk_localproxy_close (Socket s)
{
Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
#ifdef MPEXT
// WinSCP core uses do_select as signalization of connection up/down
do_select(ps->plug, INVALID_SOCKET, 0);
#endif
handle_free(ps->to_cmd_h);
handle_free(ps->from_cmd_h);
CloseHandle(ps->to_cmd_H);
CloseHandle(ps->from_cmd_H);
sfree(ps);
}
int
rb_thread_select(int max, fd_set * read, fd_set * write, fd_set * except,
struct timeval *timeout)
{
if (!read && !write && !except) {
if (!timeout) {
rb_thread_sleep_forever();
return 0;
}
rb_thread_wait_for(*timeout);
return 0;
}
else {
return do_select(max, read, write, except, timeout);
}
}
Socket make_handle_socket(HANDLE send_H, HANDLE recv_H, HANDLE stderr_H,
Plug plug, int overlapped)
{
static const struct socket_function_table socket_fn_table = {
sk_handle_plug,
sk_handle_close,
sk_handle_write,
sk_handle_write_oob,
sk_handle_write_eof,
sk_handle_flush,
sk_handle_set_frozen,
sk_handle_socket_error,
sk_handle_peer_info,
};
Handle_Socket ret;
int flags = (overlapped ? HANDLE_FLAG_OVERLAPPED : 0);
ret = snew(struct Socket_handle_tag);
ret->fn = &socket_fn_table;
ret->plug = plug;
ret->error = NULL;
ret->frozen = UNFROZEN;
bufchain_init(&ret->inputdata);
bufchain_init(&ret->stderrdata);
ret->recv_H = recv_H;
ret->recv_h = handle_input_new(ret->recv_H, handle_gotdata, ret, flags);
ret->send_H = send_H;
ret->send_h = handle_output_new(ret->send_H, handle_sentdata, ret, flags);
ret->stderr_H = stderr_H;
if (ret->stderr_H)
ret->stderr_h = handle_input_new(ret->stderr_H, handle_stderr,
ret, flags);
#ifdef MPEXT
// WinSCP core uses do_select as signalization of connection up/down
do_select(plug, INVALID_SOCKET, 1);
#endif
ret->defer_close = ret->deferred_close = FALSE;
return (Socket) ret;
}
void run_clt(char **av)
{
t_env e;
if ((e.my_sock = create_clt(av[1], ft_atoi(av[2]))) != -1)
{
init_clt(&e);
while (my_exit(1, NULL) != 1)
{
FD_COPY(&e.fd_read, &e.fd_read_cpy);
FD_COPY(&e.fd_write, &e.fd_write_cpy);
do_select(&e);
check_actions(&e);
FD_ZERO(&e.fd_read_cpy);
FD_ZERO(&e.fd_write_cpy);
}
close(e.my_sock);
}
}
static void sk_handle_close(Socket s)
{
Handle_Socket ps = (Handle_Socket) s;
#ifdef MPEXT
// WinSCP core uses do_select as signalization of connection up/down
do_select(ps->plug, INVALID_SOCKET, 0);
#endif
handle_free(ps->send_h);
handle_free(ps->recv_h);
CloseHandle(ps->send_H);
if (ps->recv_H != ps->send_H)
CloseHandle(ps->recv_H);
bufchain_clear(&ps->inputdata);
bufchain_clear(&ps->stderrdata);
sfree(ps);
}
int main(int argc, char *argv[])
{
int argi;
struct sigaction sa;
time_t lastconf = 0;
memset(&srvaddr, 0, sizeof(srvaddr));
srvaddr.sin_port = htons(1984);
srvaddr.sin_family = AF_INET;
inet_aton("127.0.0.1", (struct in_addr *) &srvaddr.sin_addr.s_addr);
for (argi = 1; (argi < argc); argi++) {
if (strncmp(argv[argi], "--confdir=", 10) == 0) {
char *p = strchr(argv[argi], '=');
CONFIGDIR = strdup(p+1);
}
else if (strncmp(argv[argi], "--srvip=", 8) == 0) {
char *p = strchr(argv[argi], '=');
inet_aton(p+1, (struct in_addr *) &srvaddr.sin_addr.s_addr);
}
}
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigmisc_handler;
sigaction(SIGHUP, &sa, NULL);
while (1) {
if (reconfig || (time(NULL) > (lastconf+60))) {
printf("(Re)loading config\n");
setuplisteners();
setupclients();
reconfig = 0;
lastconf = time(NULL);
}
do_clients();
do_select();
}
return 0;
}
int _apdu_select(struct _sim *s, uint16_t id)
{
uint8_t sw1, sw2;
if ( !do_select(s, id) )
return 0;
sw1 = xfr_rx_sw1(s->s_xfr);
if ( sw1 != SIM_SW1_SHORT )
return 0;
sw2 = xfr_rx_sw2(s->s_xfr);
if ( !do_get_response(s, sw2) )
return 0;
sw1 = xfr_rx_sw1(s->s_xfr);
if ( sw1 != SIM_SW1_SUCCESS )
return 0;
return 1;
}
void select_resource::init()
{
setWindowTitle("Select a resource");
setWindowIcon(QIcon(":/core/life.png"));
setFixedSize(200, 150);
setModal(true);
QGridLayout* l = new QGridLayout(this);
// ComboBox
type_ = new QComboBox(this);
type_->addItem(resource_->str_type_item(data::DECOR), QVariant(data::DECOR));
type_->addItem(resource_->str_type_item(data::SIGN), QVariant(data::SIGN));
type_->addItem(resource_->str_type_item(data::BASEGROUND), QVariant(data::BASEGROUND));
type_->addItem(resource_->str_type_item(data::FOREGROUND), QVariant(data::FOREGROUND));
type_->addItem(resource_->str_type_item(data::DEATH_ITEM), QVariant(data::DEATH_ITEM));
//type_->addItem(QString("Other"));
connect(type_, SIGNAL(currentIndexChanged(int)), SLOT(do_update_list()));
l->addWidget(type_, 0, 0, 1, 3);
// FIXME: Set current Index
// ListWidget
list_ = new QListWidget(this);
list_->setViewMode(QListWidget::IconMode);
do_update_list();
l->addWidget(list_, 1, 0, 1, 3);
// Buttons
QPushButton* btn_cancel = new QPushButton("Cancel", this);
btn_cancel->setMaximumWidth(80);
l->addWidget(btn_cancel, 2, 1);
connect(btn_cancel, SIGNAL(clicked()), SLOT(do_cancel()));
QPushButton* btn_select = new QPushButton("Select", this);
btn_select->setMaximumWidth(80);
l->addWidget(btn_select, 2, 2);
connect(btn_select, SIGNAL(clicked()), SLOT(do_select()));
}
int loop(t_server *server)
{
t_client *client;
FD_ZERO(&server->fd_read);
FD_ZERO(&server->fd_write);
server->fd_max = 0;
client = server->client;
while (client != NULL)
{
if (client->type != 0)
{
FD_SET(client->sock, &server->fd_read);
FD_SET(client->sock, &server->fd_write);
server->fd_max = client->sock;
}
client = client->next;
}
if (do_select(server) == 0)
return (0);
client = server->client;
loop_end(server, client);
return (1);
}
/* Since we are operating in binary mode, the return value from control
* is irrelevant, as long as it is not negative.
*/
static int control(ErlDrvData drv_data, unsigned int command, char *buf,
int len, char **rbuf, int rlen)
{
int r;
char* s;
s = get_s(buf, len);
switch (command) {
case DRV_CONNECT:
r = do_connect(s, (our_data_t*)drv_data);
break;
case DRV_DISCONNECT:
r = do_disconnect((our_data_t*)drv_data);
break;
case DRV_SELECT:
r = do_select(s, (our_data_t*)drv_data);
break;
default:
r = -1;
break;
}
free_s(s);
return r;
}
