RaspCam/camera/cameramanager/commander.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/select.h>
#include <netdb.h>
#include <errno.h>
#include <unistd.h>

#include "commander.h"


static int commander_sock = 0;

int commander_connect(char* host, char* port, char* serial_number, char* product_key, char* rtmp_handle) {		
	struct addrinfo hints;
	struct addrinfo* results;
	struct addrinfo* n;
	int gai_err;
	char buf[256];
	buf[255] = '\0';
	
	printf("[CameraManager] : Connecting with the CameraCommander at %s:%s...", host, port);
	if((commander_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		printf("Failed\n");
		perror("Error (socket)");
		exit(errno);
	}
	
	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;
	hints.ai_protocol = 0;

	if((gai_err = getaddrinfo(host, port, &hints, &results))) {
		printf("Failed\n");
		fprintf(stderr, "Error (getaddrinfo) : %s\n", gai_strerror(gai_err));
		commander_close();
		exit(-1);
	}

	for(n = results; n != NULL; n = n->ai_next) {
		if(!connect(commander_sock, n->ai_addr, n->ai_addrlen)) {
			printf("Success\n");
			break;
		}
	}

	if(n == NULL) {
		printf("Failed\n");
		commander_close();
		return -1;
	}

	freeaddrinfo(results);

	printf("[CameraManager] : Authentication...");

	sprintf(buf, "%s:%s", serial_number, product_key);
	if(commander_send(buf)) {
		printf("Failed\n");
		return -2;
	}

	if(commander_receive(buf, 255)) {
		printf("Failed\n");
		return -2;
	}

	if(strstr(buf, "accepted") == buf && buf[8] == ':' && strlen(buf) > 9) {
		printf("Accepted\n");
		strcpy(rtmp_handle, buf + 9);
	} else if(!strcmp(buf, "refused")){
		printf("Refused\n");
		commander_close();
		return -3;
	} else {
		printf("Failed\n");
		printf("[CameraManager] : CameraCommander error =  %s\n", buf);
		commander_close();
		return -4;
	}

	return 0;
}

int commander_wait_activity() {	
	fd_set readfs;
	struct timeval timeout;
	int ret;

	timeout.tv_sec = 0;
	timeout.tv_usec = 50000;

	FD_ZERO(&readfs);
	FD_SET(commander_sock, &readfs);

	if((ret = select(commander_sock + 1, &readfs, NULL, NULL, &timeout)) == -1) {
		perror("Error (select)");
		commander_close();
		exit(errno);
	}

	if(!ret || !FD_ISSET(commander_sock, &readfs)) {
		return 0;
	}
	return 1;
}

int commander_receive(char* buf, int max) {
	unsigned int pos = 0;
	ssize_t ret;
	if(max <= 0) {
		return 0;
	}
	while(pos < max && (ret = recv(commander_sock, buf + pos, 1, 0)) == 1 && buf[pos] != '\0') {
		pos++;
	}
	if(ret == -1) {
		perror("Error (recv)");
		commander_close();
		exit(errno);
	}
	if(ret == 0 && pos == 0) {
		fprintf(stderr, "[CameraManager] (error) : Connection lost\n");
		commander_close();
		return -1;
	}
	return 0;
}

int commander_send(char* msg) {
	int ret;
	int msg_size = strlen(msg);
	if((ret = send(commander_sock, msg, msg_size + 1, 0)) == -1) {
		perror("Error (send)");
		commander_close();
		exit(errno);
	}
	if(ret != msg_size + 1) {
		fprintf(stderr, "[CameraManager] (error) : Connection lost\n");
		commander_close();
		return -1;
	}
	return 0;
}

void commander_close() {
	if(commander_sock != 0) {
		close(commander_sock);
		commander_sock = 0;
	}
}