int hub(const char * service)
{
int sockserver;
struct sockaddr_in address;
socklen_t length = sizeof(struct sockaddr_in);
if ((sockserver = create_tcp_server(NULL, service)) < 0) {
return -1;
}
if (nonblock(sockserver) < 0) {
return -1;
}
char buffer[BUF_SIZE];
int sockclient[MAX_CONNECTION];
int sockclientc = 0;
int i, j, r, sock, run, dataread;
fd_set listenfdset;
run = 1;
while (run) {
FD_ZERO(&listenfdset);
FD_SET(sockserver, &listenfdset);
for (i = 0 ; i < sockclientc ; i++) {
FD_SET(sockclient[i], &listenfdset);
}
if (select(FD_SETSIZE, &listenfdset, NULL, NULL, NULL) < 0) {
if (errno != EINTR) {
perror("select");
return -1;
} else {
continue;
}
}
if (FD_ISSET(sockserver, &listenfdset)) {
if ((sock = accept(sockserver, (struct sockaddr*)(&address), &length)) < 0) {
perror("accept");
return -1;
}
if (nonblock(sock) < 0) {
return -1;
}
if (sockclientc == MAX_CONNECTION) {
char * toomanyco = "Sorry, no slot available, retry later\n";
if (write(sock, toomanyco, strlen(toomanyco)) < -1) {
perror("write");
}
close(sock);
} else {
sockclient[sockclientc++] = sock;
fprintf(stdout, "%i connections [+1]\n", sockclientc);
fflush(stdout);
}
}
for (i = 0 ; i < sockclientc ; i++) {
if (FD_ISSET(sockclient[i], &listenfdset)) {
r = read(sockclient[i], buffer, BUF_SIZE);
if (r <= 0) {
close(sockclient[i]);
sockclient[i] = sockclient[--sockclientc];
fprintf(stdout, "%i connections [-1]\n", sockclientc);
fflush(stdout);
if (r < 0 && errno != ECONNRESET) {
perror("read");
//return -1;
}
} else {
if (dispatches(sockclientc, sockclient, i, r, buffer) < 0) {
return -1;
}
}
}
}
}
}
/**
@todo Still to setup
Dispatch table methods
Interface prototypes
*/
void Type::init() {
static bool inited= false;
if(!inited) {
Type placeHolderType;
inited= true;
// create the types
for(size_t type= 0; type < sizeof(gTypeBootStrapTable)/sizeof(gTypeBootStrapTable[0]); ++type) {
const_cast<Type*>(gTypeBootStrapTable[type].type)->assign(new Extrinsic(placeHolderType, Type::kCountOfMembers), Pointer::DoNotRetain);
}
// create the interfaces
for(size_t interface= 0; interface < sizeof(gInterfaceBootStrapTable)/sizeof(gInterfaceBootStrapTable[0]); ++interface) {
gInterfaceBootStrapTable[interface].assign(new Extrinsic(Interface::type, Interface::kCountOfMembers), Pointer::DoNotRetain);
}
// assign interface of all interfaces
for(size_t interface= 0; interface < sizeof(gInterfaceBootStrapTable)/sizeof(gInterfaceBootStrapTable[0]); ++interface) {
gInterfaceBootStrapTable[interface]._interface= &gInterfaceBootStrapTable[iInterface].ref<GenericInstance>();
Pointer::_retain(gInterfaceBootStrapTable[interface]._interface);
}
// initialize all Pointer types and interfaces
for(size_t type= 0; type < sizeof(gTypeBootStrapTable)/sizeof(gTypeBootStrapTable[0]); ++type) {
size_t index= gTypeBootStrapTable[type].interfaceIndex;
*const_cast<Type*>(gTypeBootStrapTable[type].type)= const_cast<GenericInstance*>(&Type::type.ref<GenericInstance>());
*const_cast<Interface*>(gTypeBootStrapTable[type].interface)= gInterfaceBootStrapTable[index];
}
// set the name, parent and dispatches (and fill in interface of the dispatch)
for(size_t type= 0; type < sizeof(gTypeBootStrapTable)/sizeof(gTypeBootStrapTable[0]); ++type) {
size_t index= gTypeBootStrapTable[type].interfaceIndex;
List dispatches(1);
List members(gTypeBootStrapTable[type].memberCount);
List constants(gTypeBootStrapTable[type].constantCount);
dispatches.set(0, Dispatch(gInterfaceBootStrapTable[index]));
const_cast<Type*>(gTypeBootStrapTable[type].type)->ref<Extrinsic>()[Name]= ASCIIText(gTypeBootStrapTable[type].name);
const_cast<Type*>(gTypeBootStrapTable[type].type)->ref<Extrinsic>()[Parent]= Instance::type;
const_cast<Type*>(gTypeBootStrapTable[type].type)->ref<Extrinsic>()[Dispatches]= dispatches;
const_cast<Type*>(gTypeBootStrapTable[type].type)->ref<Extrinsic>()[Constants]= constants;
const_cast<Type*>(gTypeBootStrapTable[type].type)->ref<Extrinsic>()[Members]= members;
}
// Fill in a list of all the known types so far
List typeList(sizeof(gTypeBootStrapTable)/sizeof(gTypeBootStrapTable[0]));
for(size_t type= 0; type < sizeof(gTypeBootStrapTable)/sizeof(gTypeBootStrapTable[0]); ++type) {
typeList.set(type, *gTypeBootStrapTable[type].type);
}
Type *typeType= const_cast<Type*>(&Type::type); ///< Get Type's type to fix up
List &members= typeType->ref<Extrinsic>()[Members].ref<List>();
List &constants= typeType->ref<Extrinsic>()[Constants].ref<List>();
Reference allTypes(typeList);
members.set(Name, gInterfaceBootStrapTable[iText]);
members.set(Parent, gInterfaceBootStrapTable[iType]);
members.set(Dispatches, gInterfaceBootStrapTable[iList]);
members.set(Constants, gInterfaceBootStrapTable[iList]);
members.set(Members, gInterfaceBootStrapTable[iList]);
constants.set(AllTypes, allTypes);
// call the init for every type
for(size_t type= 0; type < sizeof(gTypeBootStrapTable)/sizeof(gTypeBootStrapTable[0]); ++type) {
gTypeBootStrapTable[type].init();
}
}
}
