/* called when we have datagrams to read */
void service_socket(pmtr_t *cfg) {
ssize_t rc;
int *fd = (int*)utarray_front(cfg->listen); assert(fd);
do {
rc = read(*fd, buf, sizeof(buf)); /* fd is non-blocking, thus */
if (rc > 0) decode_msg(cfg,buf,rc); /* we get rc==-1 after last */
} while (rc >= 0);
}
static int encode_decode_tests(void)
{
char buf[100];
ademco_contactid_receiver_state_t *receiver;
ademco_contactid_sender_state_t *sender;
logging_state_t *logging;
ademco_contactid_report_t result;
int i;
printf("Encode and decode tests\n");
if ((receiver = ademco_contactid_receiver_init(NULL, NULL, NULL)) == NULL)
return 2;
logging = ademco_contactid_receiver_get_logging_state(receiver);
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
span_log_set_tag(logging, "Ademco-rx");
if ((sender = ademco_contactid_sender_init(NULL, NULL, NULL)) == NULL)
return 2;
logging = ademco_contactid_sender_get_logging_state(sender);
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
span_log_set_tag(logging, "Ademco-tx");
for (i = 0; i < 5; i++)
{
if (encode_msg(buf, &reports[i]) < 0)
{
printf("Bad encode message\n");
return -1;
}
printf("'%s'\n", buf);
if (decode_msg(&result, buf))
{
printf("Bad decode message\n");
return -1;
}
ademco_contactid_receiver_log_msg(receiver, &result);
printf("\n");
if (memcmp(&reports[i], &result, sizeof(result)))
{
printf("Received message does not match the one sent\n");
return -1;
}
}
if (encode_msg(buf, &reports[5]) >= 0)
{
printf("Incorrectly good message\n");
return -1;
}
printf("'%s'\n", buf);
printf("\n");
printf(" Passed\n");
return 0;
}
static gboolean received_data(GIOChannel *channel, GIOCondition condition,
gpointer user_data)
{
unsigned char buf[128];
struct msghdr msg;
struct iovec iov;
struct cmsghdr *cmsg;
struct timeval *tv;
struct timespec mrx_time;
char aux[128];
ssize_t len;
int fd;
if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
connman_error("Problem with timer server channel");
channel_watch = 0;
return FALSE;
}
fd = g_io_channel_unix_get_fd(channel);
iov.iov_base = buf;
iov.iov_len = sizeof(buf);
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = aux;
msg.msg_controllen = sizeof(aux);
len = recvmsg(fd, &msg, MSG_DONTWAIT);
if (len < 0)
return TRUE;
tv = NULL;
clock_gettime(CLOCK_MONOTONIC, &mrx_time);
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level != SOL_SOCKET)
continue;
switch (cmsg->cmsg_type) {
case SCM_TIMESTAMP:
tv = (struct timeval *) CMSG_DATA(cmsg);
break;
}
}
decode_msg(iov.iov_base, iov.iov_len, tv, &mrx_time);
return TRUE;
}
/*
* FastOpraDecoder
*
* This calls the correct decoder function based on the message category.
*/
static inline int FastOpraDecoder(Fast * fast, char * decoded_msg, char category, OpraMsg_v2 * msg)
{
FastOpra_decode_t* decode_msg = NULL;
if ((category >= 'C') && (category <= 'k')) {
decode_msg = FastOpra_msg_ops[category - 'A'];
}
if (decode_msg == NULL) {
return decode_OpraFastDefMsg_v2(fast, decoded_msg, msg);
}
else {
return decode_msg(fast, decoded_msg, msg);
}
}
static
int handle_run_msg(pv_thread_params_t * params, uint32_t msg)
{
void * addr;
char code = decode_msg(msg, &addr);
if (code == PV_MSG_EXIT) {
printf("handle_run_msg: exiting: msg=%d, addr=%p\n", code, addr);
return 0;
}
/* only recv for now */
PVLayerCube * activity = (PVLayerCube *) get_data(addr, params->max_recv_size);
printf("handle_run_msg: activity.size=%ld\n", activity->size);
return 0;
}
static void update_pbring(void *arg, long l)
{
pbring_inst_t *p = (pbring_inst_t *) arg;
ring_size_t cmdsize = record_next_size(&p->to_rt_rb);
if (cmdsize < 0) {
// command ring empty
*(p->underrun) += 1;
return;
}
const void *cmdbuffer = record_next(&p->to_rt_rb);
pb_istream_t stream = pb_istream_from_buffer((void *) cmdbuffer, cmdsize);
int retval;
if (!decode_msg(p, &stream)) {
// process command here
// prepare reply
tx.has_motstat = true;
tx.type = pb_ContainerType_MT_MOTSTATUS;
tx.note.funcs.encode = npb_encode_string;
tx.note.arg = "hi there!";
tx.motstat = (pb_MotionStatus) {
.commandEcho = rx.motcmd.command,
.commandNumEcho = rx.motcmd.commandNum,
.commandStatus = pb_cmd_status_t_EMCMOT_COMMAND_OK,
.has_carte_pos_fb = true,
.carte_pos_fb = {
.tran = {
.has_x = true,
.x = 42.0,
.has_y = true,
.y = 13.56,
.has_z = true,
.z = 27.12
},
.has_a = true,
.a = 3.14
}
};
static void dtmf_digit_delivery(void *user_data, const char *digits, int len)
{
ademco_contactid_receiver_state_t *s;
ademco_contactid_report_t report;
s = (ademco_contactid_receiver_state_t *) user_data;
memcpy(&s->rx_digits[s->rx_digits_len], digits, len);
s->rx_digits_len += len;
if (s->rx_digits_len == 16)
{
s->rx_digits[16] = '\0';
if (decode_msg(&report, s->rx_digits) == 0)
{
ademco_contactid_receiver_log_msg(s, &report);
if (s->callback)
s->callback(s->callback_user_data, &report);
s->step++;
}
s->rx_digits_len = 0;
}
}
int main(int argc, char *argv[]) {
int server_port;
int socket_desc;
int res = 0;
int print_i = 0; // index of message that should be printed next
char buf[BUFFER_SIZE];
char queue[QUEUE_SIZE][BUFFER_SIZE] = {{0}};
if(DROP_PACKETS) srand(time(NULL));
// Check number of arguments, terminate when server port is not a positive number
if(argc != 2 || (server_port = strtol(argv[1], NULL, 0)) <= 0) {
fprintf(stderr, "Invalid parameters. Please provide server port as a first parameter.\n");
return 1;
}
socket_desc = socket(PF_INET, SOCK_DGRAM, 0);
if(socket_desc < 0) {
perror("Cannot open socket");
return 1;
}
struct sockaddr_in address;
address.sin_family = AF_INET;
address.sin_addr.s_addr = htonl(INADDR_ANY);
address.sin_port = htons(server_port);
// Bind to specified port
res = bind(socket_desc, (struct sockaddr *)&address, sizeof(address));
if(res < 0){
perror("Cannot bind to port");
return 1;
}
fprintf(stderr, "Running server on port %d!\n", server_port);
struct sockaddr_in client_address;
socklen_t client_address_len = sizeof(client_address);
int len, sequence = -1;
while(recvfrom(socket_desc, buf, sizeof(buf), 0, (struct sockaddr *)&client_address, &client_address_len) >= 0){
// on client_address change reset print_i
sequence = decode_msg(buf, &len);
if(sequence >= 0){
// save message
memcpy(queue[sequence % QUEUE_SIZE], buf, len+META_LEN);
// send acknowledgement
send_packet(socket_desc, buf, len+META_LEN, (struct sockaddr *)&client_address, client_address_len);
// print all messages that can be printed
while(decode_msg(queue[print_i % QUEUE_SIZE], NULL) == print_i) {
print_msg(queue[print_i % QUEUE_SIZE]);
print_i++;
}
}
}
close(socket_desc);
return 0;
}
int main(int argc, char *argv[])
{
int sockfd,portnum,n,i,flag=0;
struct sockaddr_in serv_addr;
struct hostent *servname;
struct msg_header mess_hdr;
struct attr_header atri_hdr;
struct attr_header atri_hdr2;
char *buff;
char recv_buff[1024];
fd_set readfiledesc;
char username_buff[16];
char message_buff[512];
FD_ZERO (&readfiledesc);
if(argc<4)
{
fprintf(stderr,"usage : client username hostname portno\n" );
exit(0);
}
portnum=atoi(argv[3]);
sockfd = socket(AF_INET, SOCK_STREAM,0);
if(sockfd==-1)
{
perror("error opening socket!");
exit(0);
}
servname=gethostbyname(argv[2]);
if(servname==NULL)
{
fprintf(stderr,"cannot find host");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)servname->h_addr,(char *)&serv_addr.sin_addr.s_addr,servname->h_length);
serv_addr.sin_port = htons(portnum);
if(connect(sockfd,&serv_addr,sizeof(serv_addr))<0)
{
perror("Error during connection.");
exit(0);
}
bzero(username_buff,16);
strcpy(username_buff,argv[1]);
mess_hdr.vrsn=3;
mess_hdr.type=2;
atri_hdr.type=2;
atri_hdr.length=(strlen(username_buff)+1);
buff = encode_msg(&mess_hdr, &atri_hdr, NULL, username_buff, NULL);
n = write(sockfd,buff,mess_hdr.length);
free(buff);
//SEND USERNAME AS JOIN FUNCTION
//n = write(sockfd,username_buff,strlen(username_buff));
if(n==-1)
{
perror("Error writing username to server\n");
exit(0);
}
FD_SET(0, &readfiledesc);
FD_SET(sockfd, &readfiledesc);
while(1)
{
if (select(sockfd+1, &readfiledesc, NULL, NULL, NULL) == -1)
{
perror("Error in select function.");
exit(0);
}
for(i = 0; i <= sockfd; i++)
{
if (FD_ISSET(i, &readfiledesc))
{
if (i == 0)
{
//THIS IS FOR READING FROM KEYBOARD
fgets(message_buff, sizeof(message_buff), stdin);
mess_hdr.vrsn=3;
mess_hdr.type=4;
atri_hdr.type=4;
atri_hdr.length=(strlen(message_buff)+1);
buff = encode_msg(&mess_hdr, &atri_hdr, NULL, message_buff, NULL);
if (buff != NULL){
n = write(sockfd,buff,mess_hdr.length);
free(buff);
message_buff[0]='\0';
}
else {
n=-1;
}
//SEND MESSAGE TO SERVER
//n = write(sockfd,message_buff,strlen(message_buff));
if (n == -1)
{
perror("Error sending the message");
exit(0);
}
flag=1;
}
if ((i == sockfd)&&(flag==0))
{
//THIS IS FOR READING FROM THE SERVER
n = recv(sockfd, recv_buff, 4, 0);
if (n == -1)
{
perror("Error during receive");
exit(0);
}
decode_msg_header(recv_buff,&mess_hdr);
bzero(recv_buff, 1024);
n = recv(sockfd, recv_buff,mess_hdr.length-4,0);
int type = (int) mess_hdr.type;
decode_msg(recv_buff, &type, &atri_hdr, &atri_hdr2, username_buff, message_buff);
if(mess_hdr.type==3)
{
printf("%s: ",username_buff);
printf("%s\n",message_buff);
}
if(mess_hdr.type==8)
{
printf("%s is ONLINE!\n",username_buff);
}
if(mess_hdr.type==6)
{
printf("%s is OFFLINE\n",username_buff);
}
//buff[n] = '\0';
//printf("%s\n",buff);
}
FD_SET(0, &readfiledesc);
FD_SET(sockfd, &readfiledesc);
}
}
flag=0;
}
close(sockfd);
return 0;
}
