static mp_obj_t py_select(uint n_args, const mp_obj_t *args)
{
int nfds=0; //highest-numbered fd plus 1
timeval tv={0};
fd_set rfds, wfds, xfds;
mp_obj_t *rlist, *wlist, *xlist;
uint rlist_len, wlist_len, xlist_len;
/* read args */
mp_obj_get_array(args[0], &rlist_len, &rlist);
mp_obj_get_array(args[1], &wlist_len, &wlist);
mp_obj_get_array(args[2], &xlist_len, &xlist);
if (n_args == 4) {
float timeout = mp_obj_get_float(args[3]);
tv.tv_sec = (int)timeout;
tv.tv_usec = (timeout-(int)timeout)*1000*1000;
}
// add fds to their respective sets
set_fds(&nfds, rlist, rlist_len, &rfds);
set_fds(&nfds, wlist, wlist_len, &wfds);
set_fds(&nfds, xlist, xlist_len, &xfds);
// call select
nfds = select(nfds+1, &rfds, &wfds, &xfds, &tv);
// if any of the read sockets is closed, we add it to the read fd set,
// a subsequent call to recv() returns 0. This behavior is consistent with BSD.
for (int i=0; i<rlist_len; i++) {
socket_t *s = rlist[i];
if (wlan_get_fd_state(s->fd)) {
FD_SET(s->fd, &rfds);
nfds = max(nfds, s->fd);
}
}
// return value; a tuple of 3 lists
mp_obj_t fds[3] = {
mp_obj_new_list(0, NULL),
mp_obj_new_list(0, NULL),
mp_obj_new_list(0, NULL)
};
// On success, select() returns the number of file descriptors contained
// in the three returned descriptor sets which may be zero if the timeout
// expires before anything interesting happens, -1 is returned on error.
if (nfds == -1) { // select failed
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "select failed"));
} else if (nfds) { // an fd is ready
get_fds(rlist, rlist_len, fds[0], &rfds);
get_fds(wlist, wlist_len, fds[1], &wfds);
get_fds(xlist, xlist_len, fds[2], &xfds);
} // select timedout
return mp_obj_new_tuple(3, fds);
}
int wait_for_input(t_socket *socket)
{
char *in[2];
t_buffs buffs;
fd_set fs[2];
char *cmd;
struct timeval tv;
if (!create_buffer(&buffs) || !(in[0] = malloc(4097)) ||
!(in[1] = malloc(4097)) || !memset(in[0], 0, 4097) ||
!memset(in[1], 0, 4097) || gethostname(in[1], 4096) == -1)
return (-1);
while (1)
{
tv.tv_sec = 1;
tv.tv_usec = 0;
set_fds(&fs[1], &fs[0], socket->fd, &buffs);
if (select(socket->fd != -1 ? socket->fd + 1 : 1,
&fs[0], &fs[1], NULL, &tv) == -1)
return (puterr_int(ERR_SELECT, -1));
if (!(cmd = read_all(socket->fd, &fs[0], &buffs, in)) ||
write_all(&fs[1], &buffs, socket->fd) == -1 ||
(cmd && strcmp(cmd, "") && parse_cmd(cmd, socket,
&buffs, in[0]) == -1))
return (free(in[0]), free(in[1]), -1);
}
}
int receive_clients(int fd)
{
t_fd fds;
int ret;
t_all all;
init_buffer(&(all.buf));
all.fds = &fds;
all.channel = NULL;
all.fds->fd_s = fd;
all.actual = NULL;
new_channel(&all, "toto");
new_channel(&all, "titi");
if ((add_fd(&all, SERVER_ID, fd, &serv_ptr)) == -1)
return (-1);
while (1)
{
all.fds->max_fd = set_fds(&all, &(all.fds->fd_read));
FD_ZERO(&(all.fds->fd_write));
if ((ret = select(all.fds->max_fd + 1, &(all.fds->fd_read),
&(all.fds->fd_write),
NULL, NULL)) == -1)
return (1);
check_fd(&all);
}
return (0);
}
static PyObject*
PyEvents_WaitForEvent(PyObject* unused, PyObject* args)
{
int nfds;
fd_set readfds;
fd_set writefds;
fd_set errorfds;
struct timeval timeout;
unsigned long waittime;
long milliseconds;
long result = 0;
if (!PyArg_ParseTuple(args, "k", &milliseconds)) return NULL;
waittime = check_timers();
if (waittime > 0) {
if (waittime < milliseconds) milliseconds = waittime;
timeout.tv_sec = milliseconds / 1000;
timeout.tv_usec = 1000 * (milliseconds % 1000);
nfds = set_fds(&readfds, &writefds, &errorfds);
if (select(nfds, &readfds, &writefds, &errorfds, &timeout)==-1)
return PyErr_SetFromErrno(PyExc_RuntimeError);
}
return PyInt_FromLong(result);
}
int main(){
struct username username[MAXCLIENTS];
fd_set rfds;
time_t t;
int server_socket, client_socket, max, i, j, laenge, anzahln, erg;
struct sockaddr_in serverinfo, clientinfo;
unsigned short int portnummer=5000;
char serverIp[]="127.0.0.1";
FILE *verlauf;
for(i=0;i<MAXCLIENTS;i++){
memset(username[i].username,'\0',NAME);
}
verlauf=fopen("./chat_Verlauf.txt","r");
if(verlauf==NULL){
verlauf=fopen("./chat_Verlauf.txt","w");
printf("\nchat_Verlauf.txt neu erstellt");
}
fclose(verlauf);
printf("\nserver: socket()..");
server_socket=socket(AF_INET,SOCK_STREAM,0);
serverinfo.sin_family=AF_INET;
inet_pton(AF_INET,serverIp,&serverinfo.sin_addr.s_addr);
serverinfo.sin_port=htons(portnummer);
laenge=sizeof(serverinfo);
printf("\nserver:bind()...");
bind(server_socket, (struct sockaddr *)&serverinfo, laenge);
printf("\nserver:listen()...");
printf("\nserver mit IP: %s",serverIp);
printf("\nan Port 5000 wartet...");
listen(server_socket,15);
for(i=0;i<MAXCLIENTS; i++){
username[i].client=-1;
}
i=0;
while(1){
fflush(stdout);
max = set_fds(server_socket, username, &rfds);
select(max+1, &rfds, NULL, NULL, NULL);
if(FD_ISSET(server_socket, &rfds)){
if(i<MAXCLIENTS){
client_socket=accept(server_socket, NULL, 0);
laenge=read(client_socket,username[i].username,sizeof(username[i].username));
username[i].username[laenge]='\0';
t=time(NULL);
username[i].time=(char *)malloc(TIME);
username[i].time=ctime(&t);
username[i].time[24]='\0';
printf("\nNeuer Teilnehmer ist aufgenommen. %s ist seit %s online!\n",username[i].username,username[i].time);
username[i].client=client_socket;
for(j=0;j<MAXCLIENTS;j++)
if(username[j].client==username[i].client)
continue;
write(username[j].client,username[i].username,sizeof(username[i].username));
i++;
}
else{
printf("\nServer voll\n");
send(client_socket,"\nServer ist voll!\n",sizeof("\nServer ist voll!\n"),0);
continue;
}
continue;
}
i = com(username,&rfds, i);
}
}
static int wait_for_stdin(void)
{
int fd;
int mask;
int fd_stdin = fileno(stdin);
int ready;
int nfds;
long int waittime;
fd_set readfds;
fd_set writefds;
fd_set errorfds;
struct timeval timeout;
struct timeval* ptimeout;
SocketObject* socket;
PyGILState_STATE gstate;
PyObject* exception_type;
PyObject* exception_value;
PyObject* exception_traceback;
PyObject* result;
PyObject* arguments;
while (1) {
nfds = set_fds(&readfds, &writefds, &errorfds);
FD_SET(fd_stdin, &readfds);
if (fd_stdin >= nfds) nfds = fd_stdin + 1;
waittime = process_timers();
if (waittime == ULONG_MAX) ptimeout = NULL;
else {
timeout.tv_sec = waittime / 1000;
timeout.tv_usec = 1000 * (waittime % 1000);
ptimeout = &timeout;
}
if (select(nfds, &readfds, &writefds, &errorfds, ptimeout)==-1)
{
if (errno==EINTR) raise(SIGINT);
return -1;
}
if (FD_ISSET(fd_stdin, &readfds)) break;
socket = notifier.firstSocket;
while (socket)
{
ready = 0;
fd = socket->fd;
mask = socket->mask;
switch (mask) {
case PyEvents_READABLE: ready = FD_ISSET(fd, &readfds); break;
case PyEvents_WRITABLE: ready = FD_ISSET(fd, &writefds); break;
case PyEvents_EXCEPTION: ready = FD_ISSET(fd, &errorfds); break;
}
if (ready) {
gstate = PyGILState_Ensure();
PyErr_Fetch(&exception_type, &exception_value, &exception_traceback);
result = NULL;
arguments = Py_BuildValue("(ii)", fd, mask);
if (arguments) {
PyObject* callback = socket->callback;
result = PyEval_CallObject(callback, arguments);
Py_DECREF(arguments);
}
if (result) Py_DECREF(result);
else PyErr_Print();
PyErr_Restore(exception_type, exception_value, exception_traceback);
PyGILState_Release(gstate);
}
socket = socket->next;
}
}
return 1;
}
