void registerHandle(struct ClientNode *client)
{
// HEADER[kChatHeaderSize] handleLen[1] handle[handleLen]
uint8_t *buf = (uint8_t *)client->packetData;
uint8_t handleLen = *(buf + kChatHeaderSize);
// Make sure we have received a buffer big enough to
// contain the handle
if (client->packetLength < (kChatHeaderSize + handleLen + 1)) {
respondToClient(client, FLAG_INIT_ERR, NULL, 0);
removeClient(client);
return;
}
char *clientHandle = malloc(handleLen+1);
if (clientHandle == NULL) {
perror("registerHandle:malloc");
exit(1);
}
memcpy(clientHandle, buf + kChatHeaderSize + 1, handleLen);
clientHandle[handleLen] = '\0';
// Make sure this handle isn't already registered
if (clientNamed(clientHandle) && (clientNamed(clientHandle) != client)) {
respondToClient(client, FLAG_INIT_ERR, NULL, 0);
removeClient(client);
return;
}
client->clientName = clientHandle;
respondToClient(client, FLAG_INIT_ACK, NULL, 0);
}
void forwardMessage(struct ClientNode *client)
{
char handle[MAX_HANDLE_LENGTH];
uint8_t *index = (uint8_t *) client->packetData;
switch (client->packetData->flag) {
case FLAG_MSG_REQ:
index += kChatHeaderSize;
break;
case FLAG_MSG_ACK:
index += kChatHeaderSize + sizeof(uint32_t);
break;
default:
fprintf(stderr, "ERROR: Unknown forwarding packet scheme %d\n", client->packetData->flag);
return;
break;
}
uint8_t handleSize = *index;
memcpy(handle, index+1, handleSize);
handle[handleSize] = '\0';
struct ClientNode *destClient = clientNamed(handle);
if (destClient == NULL) {
respondToClient(client, FLAG_MSG_ERR, index, handleSize+1);
return;
}
ssize_t bytesSent;
if ((bytesSent = sendErr(destClient->clientSocket, client->packetData, client->packetLength, 0)) < 0) {
perror("forwardMessage:send");
}
}
void LocalHTTPServer::readClient(QTcpSocket * socket)
{
if(socket->canReadLine())
{
QString request = socket->readLine();
QStringList tokens = request.split(REQUEST_REG_EXP);
if(tokens.size() >= 2 && tokens[0] == GET_METHOD)
{
QString queryString = QUrl(tokens[1]).query();
if(!queryString.isEmpty())
{
QUrlQuery query(queryString);
Q_EMIT newQuery(pairListToMap(query.queryItems()));
}
respondToClient(socket);
}
}
}
void clientNameRequest(struct ClientNode *client)
{
uint8_t *index = (uint8_t *)client->packetData;
index += kChatHeaderSize;
uint32_t clientIndex = *(uint32_t *)index;
clientIndex = ntohl(clientIndex);
struct ClientNode *node = clientList->firstClient;
int i;
for (i = 0;; node = node->nextClient) {
if (node && node->clientName != NULL) {
if (i == clientIndex) {
break;
}
i++;
}
}
uint8_t *payload = malloc(1 + strlen(node->clientName));
payload[0] = strlen(node->clientName);
memcpy(payload+1, node->clientName, strlen(node->clientName));
respondToClient(client, FLAG_HNDL_RESP, payload, 1 + strlen(node->clientName));
free(payload);
}
int main(int argc, char* argv[]){
// Instantiate variables
struct sockaddr_in clntAddr;
socklen_t addrLen;
//Default Values PATH = ./ and PORT=8080
char PORT[6];
ROOT = getenv("PWD");
strcpy(PORT,"8080");
int val=0;
// Parameter parsing
if (argc == 4){
if(!strcmp(argv[1], "-p")){
strcpy(PORT, argv[2]);
ROOT = malloc(strlen(argv[3]));
strcpy(ROOT,argv[3]);
}
else{
strcpy(PORT, argv[3]);
ROOT = malloc(strlen(argv[1]));
strcpy(ROOT,argv[1]);
}
}
else if (argc == 3){
strcpy(PORT, argv[2]);
}
else if (argc == 2){
ROOT = malloc(strlen(argv[1]));
strcpy(ROOT,argv[1]);
}
else{
printf("Proper use of program: ./simhttp [-p port] [filepath]"); fflush(stdout);
exit(0);
}
// End of parameter parsing
//Print system message about port and filepath information
printf("Server started at port no. %s%s%s with root directory as %s%s%s\n","\033[92m",PORT,"\033[0m","\033[92m",ROOT,"\033[0m");
fflush(stdout);
// Open connections for all clients until cap is reached
int i;
for (i = 0; i<MAXNUMCONN; i++){
clients[i]=-1;
}
openPort(PORT);
// Run until server ends
while(1){
addrLen = sizeof(clntAddr);
clients[val] = accept (listenfd, (struct sockaddr *) &clntAddr, &addrLen);
// Unspecified error in accept()
if(clients[val] < 0){
printf("accept() error"); fflush(stdout);
exit(0);
}
// No errors in accept()
else{
// Fork and if child, call respondToClient on specific client
if ( fork()==0 ){
respondToClient(val);
exit(0);
}
}
// Loop until you find an empty client slot
while(clients[val] != -1) val = (val + 1)% MAXNUMCONN;
}
//Should not reach this
return 0;
}
void getClientCount(struct ClientNode *client)
{
uint32_t numClients = clientCount();
respondToClient(client, FLAG_LIST_RESP, (uint8_t *)&numClients, sizeof(uint32_t));
}
void clientExit(struct ClientNode *client)
{
respondToClient(client, FLAG_EXIT_ACK, NULL, 0);
removeClient(client);
}
