/*
* Handle downlink data, ports that are handled are modem and diagnostics
* Return 1 - ok
* Return 0 - toggle fields are out of sync
*/
static int handle_data_dl(struct nozomi *dc, enum port_type port, u8 *toggle,
u16 read_iir, u16 mask1, u16 mask2)
{
if (*toggle == 0 && read_iir & mask1) {
if (receive_data(port, dc)) {
writew(mask1, dc->reg_fcr);
*toggle = !(*toggle);
}
if (read_iir & mask2) {
if (receive_data(port, dc)) {
writew(mask2, dc->reg_fcr);
*toggle = !(*toggle);
}
}
} else if (*toggle == 1 && read_iir & mask2) {
if (receive_data(port, dc)) {
writew(mask2, dc->reg_fcr);
*toggle = !(*toggle);
}
if (read_iir & mask1) {
if (receive_data(port, dc)) {
writew(mask1, dc->reg_fcr);
*toggle = !(*toggle);
}
}
} else {
dev_err(&dc->pdev->dev, "port out of sync!, toggle:%d\n",
*toggle);
return 0;
}
return 1;
}
int receive_message(int connection, message_t *m) {
char param[HEADER_LENGTH];
receive_data(connection, m->header, sizeof(m->header));
get_parameter(m->header, strlen(m->header), "length", param, sizeof(param));
m->data_length = atoi(param);
if (m->data_length) {
m->data = malloc(m->data_length);
receive_data(connection, m->data, m->data_length);
}
return 0;
}
int CSectionsdClient::readResponse(char* data, int size)
{
struct sectionsd::msgResponseHeader responseHeader;
receive_data((char*)&responseHeader, sizeof(responseHeader));
if ( data != NULL )
{
if ( responseHeader.dataLength != size )
return -1;
else
return receive_data(data, size);
}
else
return responseHeader.dataLength;
}
bool CSectionsdClient::getNVODTimesServiceKey(const t_channel_id channel_id, CSectionsdClient::NVODTimesList& nvod_list)
{
if (send(sectionsd::timesNVODservice, (char*)&channel_id, sizeof(channel_id)))
{
nvod_list.clear();
int nBufSize = readResponse();
char* pData = new char[nBufSize];
receive_data(pData, nBufSize);
char* dp = pData;
CSectionsdClient::responseGetNVODTimes response;
while( dp< pData+ nBufSize )
{
response.service_id = *(t_service_id *) dp; dp += sizeof(t_service_id);
response.original_network_id = *(t_original_network_id *) dp; dp += sizeof(t_original_network_id);
response.transport_stream_id = *(t_transport_stream_id *) dp; dp += sizeof(t_transport_stream_id);
response.zeit = *(CSectionsdClient::sectionsdTime*) dp; dp += sizeof(CSectionsdClient::sectionsdTime);
nvod_list.insert( nvod_list.end(), response);
}
close_connection();
return true;
}
else
{
close_connection();
return false;
}
}
int32
SendPulsesEtc()
{
BMessage m(GNASH_PULSE);
int32 code;
thread_id sender;
while (true)
{
if (B_OK != be_app_messenger.SendMessage(&m))
return -1;
unsigned int interval =
_gui->getInterval();
if (interval == 0)
interval = 15;
// interval in miliseconds, 1000 * interval in microseconds
usleep(1000 * interval);
do {
code = receive_data(&sender, NULL, 0);
} while (code == B_INTERRUPTED);
switch (code)
{
case GNASH_SEND_PULSE:
break;
case GNASH_QUITTING:
return 0;
default:
return -1;
};
}
return 0;
}
void connection::read()
{
std::array<char, 1024> buf;
auto ptr = buf.data();
auto len = buf.size();
auto res = ssize_t{0};
do
{
res = socket_.recv(ptr, len, 0);
if ( res > 0 )
{
receive_data(ptr, res);
}
else if ( res < 0 )
{
if ( socket_.last_error() == ECONNRESET )
{
stop();
}
}
else
{
stop();
}
}
while ( res != 0 && res == static_cast<ssize_t>(len) );
}
/* register and load cluster nodes */
cluster_t * register_and_load_cluster_nodes(char *addr, int port)
{
int i;
int DataNum = -1;
char Buf[MAX_BUF_LEN] = "\0";
int BufSize = MAX_BUF_LEN;
char szMsg[MAX_BUF_LEN] = "\0";
char ppData[MAX_DATA_NUM][MAX_DATA_LEN] = {0};
ServiceHandler h = -1;
// master server's addr and port
h = open_remote_service(IP_ADDR,PORT);
if(addr == NULL)
{
DataNum = 0;
}
else
{
DataNum = 1;
sprintf(ppData[0],"%s %d\0",addr,port);
debug("pasrer sprintf :%s\n",ppData[0]);
}
format_ctl_data(Buf,&BufSize,CTL_REG_CMD,ppData,DataNum);
send_data(h,Buf,BufSize);
receive_data(h,Buf,&BufSize);
int cmd = -1;
parse_ctl_data(Buf,BufSize,&cmd,&DataNum,ppData);
cluster_t *cluster = init_cluster();
add_cluster_nodes(cluster, ppData, DataNum);
close_remote_service(h);
return cluster;
}
connection receive_data(config& cfg,
connection connection_num,
bandwidth_in_ptr* bandwidth_in) // TODO: use this pointer
{
// <- just call the previous version without timeouts
return receive_data(cfg,connection_num, static_cast<unsigned>(0), bandwidth_in);
}
int my_printf(const char *fmt, ...) {
va_list args;
char str[256];
va_start(args, fmt);
vsprintf(str, fmt, args);
va_end(args);
/* setup header and body */
int header = PRINTF << 24;
header |= (strlen(str) + 1); /* make sure padded with \0 */
buff_size = 4 + strlen(str) + 1;
buff = (char *)calloc(buff_size, 1);
*(int *)(&buff[0]) = ENDIAN_FLIP(header);
int u;
for(u=0;u<strlen(str);u++) {
buff[4 + u] = str[u];
}
/* send data */
send_data((void *)buff, buff_size, 1);
/* receive data */
int len;
char *pack = receive_data(&len, 0);
int _ret = (int)*(int *)pack;
free(pack);
free(buff);
return ENDIAN_FLIP(_ret);
}
size_t my_fread(void *ptr, size_t size, size_t nitems, FILE *stream) {
int header = FREAD << 24;
header |= 12;
buff_size = 16;
buff = (char *)calloc(buff_size, 1);
*(int *)(&buff[0]) = ENDIAN_FLIP(header);
*(int *)(&buff[4]) = ENDIAN_FLIP((int)size);
*(int *)(&buff[8]) = ENDIAN_FLIP((int)nitems);
*(int *)(&buff[12]) = ENDIAN_FLIP((int)stream);
/* send data */
send_data((void *)buff, buff_size, 1);
/* receive data */
int len, j;
char *pack = receive_data(&len, (nitems * size) + 4);
char *ptrC = (char *)ptr;
for(j=4;j<len;j++) {
ptrC[j-4] = pack[j];
}
int _ret = (int)*(int *)pack;
free(pack);
/* acknowledge the host that packet has been received */
send_data((void *)(char *)&ret, 4, 1);
free(buff);
return ENDIAN_FLIP((int)_ret);
}
FILE *my_fopen(const char *filename, const char *mode) {
int header = FOPEN << 24;
header |= (strlen(filename) + strlen(mode) + 8);
buff_size = 12 + strlen(filename) + strlen(mode);
buff = (char *)calloc(buff_size, 1);
*(int *)(&buff[0]) = ENDIAN_FLIP(header);
*(int *)(&buff[4]) = ENDIAN_FLIP(strlen(filename));
*(int *)(&buff[8]) = ENDIAN_FLIP(strlen(mode));
int u, v;
for(u=0;u<strlen(filename);u++) {
buff[12 + u] = filename[u];
}
for(v=0;u<(strlen(filename) + strlen(mode));u++,v++) {
buff[12 + u] = mode[v];
}
/* send data */
send_data((void *)buff, buff_size, 1);
/* receive data */
int len;
char *pack = receive_data(&len, 0);
int _ret = (int)*(int *)pack;
free(pack);
free(buff);
_ret = ENDIAN_FLIP(_ret);
return (FILE *)_ret;
}
int my_fprintf(FILE *stream, const char *fmt, ...) {
va_list args;
char str[256];
va_start(args, fmt);
vsprintf(str, fmt, args);
va_end(args);
int header = FPRINTF << 24;
header |= 4 + strlen(str) + 1;
buff_size = 8 + strlen(str) + 1;
buff = (char *)calloc(buff_size, 1);
*(int *)(&buff[0]) = ENDIAN_FLIP(header);
*(int *)(&buff[4]) = ENDIAN_FLIP((int)stream);
int u;
for(u=0;u<strlen(str);u++) {
buff[8 + u] = str[u];
}
/* send data */
send_data((void *)buff, buff_size, 1);
/* receive data */
int len;
char *pack = receive_data(&len, 0);
int _ret = (int)*(int *)pack;
free(pack);
free(buff);
return ENDIAN_FLIP(_ret);
}
size_t my_fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream) {
int header = FWRITE << 24;
header |= 12 + (size * nitems);
buff_size = 16 + (size * nitems);
buff = (char *)calloc(buff_size, 1);
if(buff == NULL) {
xil_printf("buff == NULL\n");
exit(-1);
}
*(int *)(&buff[0]) = ENDIAN_FLIP(header);
*(int *)(&buff[4]) = ENDIAN_FLIP((int)size);
*(int *)(&buff[8]) = ENDIAN_FLIP((int)nitems);
*(int *)(&buff[12]) = ENDIAN_FLIP((int)stream);
int u;
char *ptrC = (char *)ptr;
for(u=0;u<(size * nitems);u++) {
buff[16 + u] = ptrC[u];
}
/* send data */
send_data((void *)buff, buff_size, 1);
/* receive data */
int len;
char *pack = receive_data(&len, 0);
int _ret = (int)*(int *)pack;
free(pack);
free(buff);
return ENDIAN_FLIP((int)_ret);
}
/*==================================================================================================
FUNCTION: Uart_receive
DESCRIPTION:
==================================================================================================*/
uint32 Uart_receive(UartHandle h, char* buf,uint32 bytes_to_rx)
{
UART_CONTEXT* uart_ctxt;
uint32 bytes_read;
UART_LOG_0(INFO,"+Uart_receive");
if (NULL == h)
{
UART_LOG_0(ERROR,"Calling Uart_receive with a NULL handle.");
return 0;
}
if (NULL == buf)
{
UART_LOG_0(ERROR,"Calling Uart_receive with a NULL buffer.");
return 0;
}
if (0 == bytes_to_rx) { return 0; }
uart_ctxt = (UART_CONTEXT*)h;
if (FALSE == uart_ctxt->is_port_open)
{
UART_LOG_0(ERROR,"Calling Uart_receive on a closed port.");
return 0;
}
bytes_read = receive_data(uart_ctxt,buf,bytes_to_rx);
UART_LOG_0(INFO,"-Uart_receive");
return bytes_read;
}
int main(void)
{
uint8_t *val;
USART_INIT(51);
USART_SENDSTRING("PROGRAM STARTED");
initSPI();
receive_init();
DDRD |= (1<<LEDPin); //Set LEDPin as Output
while(1)
{
USART_TRANSMIT(GetReg(CONFIG));
USART_TRANSMIT(GetReg(STATUS));
receive_data();
if(((GetReg(STATUS) & (1<<6)) != 0 ))
{
PORTD |= (1<<LEDPin);
_delay_ms(100);
PORTD &= ~(1<<LEDPin);
val = WriteToNrf(R,R_RX_PAYLOAD,val,5);
for(int i=0;i<5;i++)
{
USART_TRANSMIT(val[i]);
}
}
reset();
}
}
int main(int argc, char **argv){
if (argc != 5){
printf("Wrong args\n");
exit(0);
}
fd = open(argv[4], O_WRONLY|O_CREAT);
if (fd == -1){
printf("Error opening log file\n");
exit(1);
}
connected = 0;
all_get = 0;
start_seq_num = (unsigned int)rand();
expected_seq = 0;
last_seq = 0;
passive_fin = 0;
create_sockets();
ini_send_addr(argv[2]);
int recv_port = ini_recv_addr();
conn_server(argv[1], argv[2], argv[3], recv_port);
printf("Connection established!\n");
receive_data(argv[1], argv[2], argv[3], recv_port);
disconnect(argv[1], argv[2], argv[3], recv_port);
close_sockets();
close(fd);
return 0;
}
ER
prcv_dtq(ID dtqid, intptr_t *p_data)
{
DTQCB *p_dtqcb;
bool_t reqdsp;
ER ercd;
LOG_PRCV_DTQ_ENTER(dtqid, p_data);
CHECK_TSKCTX_UNL();
CHECK_DTQID(dtqid);
p_dtqcb = get_dtqcb(dtqid);
t_lock_cpu();
if (receive_data(p_dtqcb, p_data, &reqdsp)) {
if (reqdsp) {
dispatch();
}
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PRCV_DTQ_LEAVE(ercd, *p_data);
return(ercd);
}
void fiber_receiving(void)
{
struct nano_timer timer;
uint32_t data[2] = {0, 0};
struct net_context *ctx;
int i = 0;
ctx = get_context(&any_addr, SRC_PORT, &loopback_addr, DEST_PORT);
if (!ctx) {
PRINT("%s: Cannot get network context\n", __func__);
return;
}
nano_timer_init(&timer, data);
while (1) {
receive_data("listenFiber", ctx);
if (CONFIG_NET_15_4_LOOPBACK_NUM != 0 &&
i >= CONFIG_NET_15_4_LOOPBACK_NUM) {
nano_fiber_timer_stop(&timer);
return;
}
nano_fiber_timer_start(&timer, SLEEPTICKS);
nano_fiber_timer_test(&timer, TICKS_UNLIMITED);
i++;
}
}
static int handshake(rdma_ctx_t ctx)
{
int retval;
char data[500];
unsigned long long int vaddr = 0;
// first send mem size
sprintf(data, "%lu", ctx->rem_mem_size);
printk(KERN_WARNING "Sending: %s\n", data);
send_data(ctx, data, strlen(data));
// receive handshake data from server
retval = receive_data(ctx, data, 500);
printk(KERN_WARNING "data received: %s\n", data);
sscanf(data, "%016Lx:%u:%x:%x:%x", &ctx->rem_vaddr, &ctx->rem_rkey,
&ctx->rem_qpn, &ctx->rem_psn, &ctx->rem_lid);
LOG_KERN(LOG_INFO, ("rem_vaddr: %llu rem_rkey:%u rem_qpn:%d rem_psn:%d rem_lid:%d\n",
ctx->rem_vaddr, ctx->rem_rkey, ctx->rem_qpn, ctx->rem_psn, ctx->rem_lid));
sprintf(data, "%016Lx:%u:%x:%x:%x",
vaddr, ctx->rkey, ctx->qpn, ctx->psn, ctx->lid);
// send handshake data to server
send_data(ctx, data, strlen(data));
return 0;
}
/*
* _metric_control_response_receive
*
* Response a metric control response
*
* Returns 0 on success, -1 on error
*/
static int
_metric_control_response_receive(cerebro_t handle, int fd)
{
char buf[CEREBRO_MAX_PACKET_LEN];
unsigned int errnum;
int bytes_read;
if ((bytes_read = receive_data(fd,
CEREBRO_METRIC_CONTROL_RESPONSE_LEN,
buf,
CEREBRO_MAX_PACKET_LEN,
CEREBRO_METRIC_CONTROL_PROTOCOL_CLIENT_TIMEOUT_LEN,
&errnum)) < 0)
{
handle->errnum = errnum;
return -1;
}
if (bytes_read != CEREBRO_METRIC_CONTROL_RESPONSE_LEN)
{
handle->errnum = CEREBRO_ERR_PROTOCOL;
return -1;
}
if (_metric_control_response_check(handle, buf, bytes_read) < 0)
return -1;
return 0;
}
//! Removes a report request.
void
KPPPReportManager::DisableReports(ppp_report_type type, thread_id thread)
{
if (thread < 0)
return;
LockerHelper locker(fLock);
ppp_report_request *request;
for (int32 i = 0; i < fReportRequests.CountItems(); i++) {
request = fReportRequests.ItemAt(i);
if (request->thread != thread)
continue;
if (request->type == type || type == PPP_ALL_REPORTS)
fReportRequests.RemoveItem(request);
}
// empty message queue
while (has_data(thread)) {
thread_id sender;
receive_data(&sender, NULL, 0);
}
}
/**
* Receive a message sent from the client. It handles character stuffing
* @param con The connection pointer
* @param dest The buffer where the message will be stored
* @return Return true if is a normal message and false if is a farewell message
*/
int receive_msg(Connection* con, char* dest){
char buffer[MAX_MSG];
buffer[0] = '\0';
receive_data(con, buffer, MAX_MSG);
//For handles character stuffing
//State represents the position of the FAREWELL message that was read
//If it gets to the last character of the FAREWELL message and no character was stuffed
//then it is and actual farewell message
int i;
int state = 0, stuffed = 0;
for(i = 0; buffer[i+stuffed] != '\0'; i++){
if(state == (strlen(FAREWELL)-1) && buffer[i+stuffed] == STUFF_CHAR){
stuffed++;
state = 0;
}else if(state == (strlen(FAREWELL)-1)){
return 0;
}
if(buffer[i+stuffed] == FAREWELL[state]){
state++;
}else{
state=0;
}
dest[i] = buffer[i+stuffed];
}
dest[i] = '\0';
return 1;
}
bool CSectionsdClient::getEPGid(const event_id_t eventid, const time_t starttime, CEPGData * epgdata)
{
sectionsd::commandGetEPGid msg;
msg.eventid = eventid;
msg.starttime = starttime;
if (send(sectionsd::epgEPGid, (char *)&msg, sizeof(msg)))
{
int nBufSize = readResponse();
if (nBufSize > 0)
{
char* pData = new char[nBufSize];
if (!receive_data(pData, nBufSize))
{
/* receive_data might have timed out etc. */
delete[] pData;
close_connection();
return false;
}
close_connection();
char* dp = pData;
epgdata->eventID = *((event_id_t *)dp);
dp+= sizeof(epgdata->eventID);
epgdata->title = dp;
dp+=strlen(dp)+1;
epgdata->info1 = dp;
dp+=strlen(dp)+1;
epgdata->info2 = dp;
dp+=strlen(dp)+1;
// 21.07.2005 - rainerk
// Convert line-terminated extended events to vector of strings
dp = parseExtendedEvents(dp, epgdata);
// *dp is the length, dp+1 is the chararray[]
epgdata->contentClassification = std::string(dp+1, *dp);
dp+=*dp+1;
epgdata->userClassification = std::string(dp+1, *dp);
dp+=*dp+1;
epgdata->fsk = *dp++;
epgdata->epg_times.startzeit = ((CSectionsdClient::sectionsdTime *) dp)->startzeit;
epgdata->epg_times.dauer = ((CSectionsdClient::sectionsdTime *) dp)->dauer;
dp+= sizeof(CSectionsdClient::sectionsdTime);
delete[] pData;
return true;
}
else
printf("no response from sectionsd\n");
}
close_connection();
return false;
}
/*
*バイト列を親ノードに集約する。
*endianのことが気になる。
*同時通信は難しいが、できるかな。
*/
int fakempi_gather( sFakeMPI* fakempi, int length, void* msg, char* array )
{
if ( fakempi->myrank == 0 ){
int i;
/*
*親のデータはそのまま配列に。ただし、msgとarray[0]が同じアドレスを差している可能性があることに注意
*/
memmove( (void*)array, msg, length );
/*
*親ノードは子の問いかけを待つ。同時に待つことはできるのか？
*/
for( i=1; i<fakempi->nprocs; i++ ){
int size;
size = receive_data( fakempi->msgsocks[i], array + i*length, length );
fprintf( fakempi_verbose, "%d>%d bytes received. \n", fakempi->myrank, size );
}
}
else{
/*
*子ノードは自分のデータを送るのみ
*/
send_data( fakempi->mysock, msg, length );
fprintf( fakempi_verbose, "%d>Sent. \n", fakempi->myrank );
}
}
std::string CSectionsdClient::getStatusinformation(void)
{
std::string ret = "";
if (send(sectionsd::dumpStatusinformation))
{
int nBufSize = readResponse();
if( nBufSize > 0)
{
char* pData = new char[nBufSize];
if (!receive_data(pData, nBufSize))
{
/* receive_data might have timed out etc. */
delete[] pData;
close_connection();
return ret; // still empty.
}
ret = pData;
delete[] pData;
}
else
printf("no response from sectionsd\n");
}
close_connection();
return ret;
}
void
DumpInfo(LocalDevice* device)
{
DiscoveryAgent* dAgent = device->GetDiscoveryAgent();
if (dAgent == NULL) {
printf("DiscoveryAgent could not be located\n");
return;
}
printf("Discovering for [LocalDevice] %s\t%s\n\n",
(device->GetFriendlyName()).String(),
bdaddrUtils::ToString(device->GetBluetoothAddress()));
SimpleDiscoveryListener* dListener = new SimpleDiscoveryListener();
dAgent->StartInquiry(BT_GIAC, dListener);
thread_id sender;
(void)receive_data(&sender, NULL, 0);
printf("Retrieving names ...\n");
for (int32 index = 0 ; index < dAgent->RetrieveDevices(0).CountItems(); index++ ) {
RemoteDevice* rDevice = dAgent->RetrieveDevices(0).ItemAt(index);
printf("\t%s \t@ %s ...\n", rDevice->GetFriendlyName(true).String(),
bdaddrUtils::ToString(rDevice->GetBluetoothAddress()));
}
}
/* This function does initiate a search for a keyword in all EPG Event of the Channel channel_id in sectionsd.
The parameter search_typ does specify the search mode
0: none -> all EPG events of the channel are returned
1: keyword search in EPG Title
2: keyword search in EPG short description (INFO1)
3: keyword search in EPG description (INFO2)
In case of a match, the EPG event is added to the Eventlist eList.
*/
bool CSectionsdClient::getEventsServiceKeySearchAdd(CChannelEventList& eList,const t_channel_id channel_id,char search_typ,std::string& search_text)
{
int nBufSize=0;
nBufSize += sizeof(t_channel_id);
nBufSize += sizeof(char);
nBufSize += search_text.size()+1;
char* pSData = new char[nBufSize];
char* pSData_ptr = pSData;
*(t_channel_id*)pSData_ptr = channel_id;
pSData_ptr += sizeof(t_channel_id);
*pSData_ptr = search_typ;
pSData_ptr += sizeof(char);
strcpy(pSData_ptr,search_text.c_str());
if (send(sectionsd::allEventsChannelIDSearch, pSData, nBufSize))
{
int nBufSize2 = readResponse();
if( nBufSize2 > 0)
{
char* pData = new char[nBufSize2];
receive_data(pData, nBufSize2);
char* dp = pData;
// int a = eList.size();
while(dp < pData + nBufSize2)
{
CChannelEvent aEvent;
aEvent.eventID = *((event_id_t *) dp);
dp+=sizeof(aEvent.eventID);
aEvent.startTime = *((time_t *) dp);
dp+=sizeof(aEvent.startTime);
aEvent.duration = *((unsigned *) dp);
dp+=sizeof(aEvent.duration);
aEvent.description= dp;
dp+=aEvent.description.length()+1;
aEvent.text= dp;
dp+=aEvent.text.length()+1;
eList.push_back(aEvent);
}
// int b = eList.size() -a;
delete[] pData;
}
}
delete[] pSData;
close_connection();
return true;
}
TEST(configure_tty, with_socat)
{
int socat_pid;
int serial_fd;
unsigned char rx_buff[2048];
pthread_t thread;
socat_pid = start_socat();
serial_fd = configure_tty(tty_path);
pthread_create(&thread, NULL, write_data_thread, &serial_fd);
// read all packets
while (received_packets < number_packets) {
int n_chars = receive_data(serial_fd, rx_buff, 2048, handle_pkt);
if (n_chars == -1) {
// Happend when 'socat' didn't run correctly
// Break to prevent infinite loop
//
// Main code does also quits when ret <= 0
fprintf(stderr, "ABORTING: %s\n", strerror(errno));
break;
}
}
/* wait for writer thread */
while (pthread_tryjoin_np(thread, NULL))
sleep(1);
ASSERT_EQ(number_packets, received_packets);
kill(socat_pid, SIGINT);
}
// Main service loop of datanode
int mainLoop()
{
int server_socket = -1;
//Create a server socket and listen on it, you can implement dfs_common.c and call it here
server_socket = create_server_tcp_socket(datanode_listen_port);
assert (server_socket != INVALID_SOCKET);
// Listen to requests from the clients
for (;;)
{
struct sockaddr_in client_address;
int client_address_length = sizeof(client_address);
int client_socket = -1;
//Accept the client request
client_socket = accept(server_socket, (struct sockaddr*) &client_address, &client_address_length);
assert(client_socket != INVALID_SOCKET);
dfs_cli_dn_req_t request;
//Receive data from client_socket, and fill it to request
receive_data(client_socket, &request, sizeof(request));
requests_dispatcher(client_socket, request);
close(client_socket);
}
close(server_socket);
return 0;
}
/**
* Waits for a greet message to arrive
* @param con The connection pointer
*/
void receive_greet(Connection* con){
char buffer[MAX_MSG];
buffer[0] = '\0';
while(strcmp(buffer, GREET_MSG) != 0){
receive_data(con, buffer, MAX_MSG);
}
}
