/* *      netcam.c * *      Module for handling network cameras. * *      This code was inspired by the original netcam.c module *      written by Jeroen Vreeken and enhanced by several Motion *      project contributors, particularly Angel Carpintero and *      Christopher Price. * *      Copyright 2005, William M. Brack *      This software is distributed under the GNU Public license *      Version 2.  See also the file 'COPYING'. * * *      When a netcam has been configured, instead of using the routines *      within video.c (which handle a CCTV-type camera) the routines *      within this module are used.  There are only four entry points - *      one for "starting up" the camera (netcam_start), for "fetching a *      picture" from it (netcam_next), one for cleanup at the end of a *      run (netcam_cleanup), and a utility routine for receiving data *      from the camera (netcam_recv). * *      Two quite different types of netcams are handled.  The simplest *      one is the type which supplies a single JPEG frame each time it *      is accessed.  The other type is one which supplies an mjpeg *      stream of data. * *      For each of these cameras, the routine taking care of the netcam *      will start up a completely separate thread (which I call the "camera *      handler thread" within subsequent comments).  For a streaming camera, *      this handler will receive the mjpeg stream of data from the camera, *      and save the latest complete image when it begins to work on the next *      one.  For the non-streaming version, this handler will be "triggered" *      (signalled) whenever the main motion-loop asks for a new image, and *      will start to fetch the next image at that time.  For either type, *      the most recent image received from the camera will be returned to *      motion. */#include "motion.h"#include <netdb.h>#include <netinet/in.h>#include <regex.h>                  /* For parsing of the URL */#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/socket.h>#include <sys/types.h>#include "netcam_ftp.h"#define CONNECT_TIMEOUT        10   /* timeout on remote connection attempt */#define READ_TIMEOUT            5   /* default timeout on recv requests */#define MAX_HEADER_RETRIES      5   /* Max tries to find a header record */#define MINVAL(x, y) ((x) < (y) ? (x) : (y))/* * The macro NETCAM_DEBUG is for development testing of this module. * The macro SETUP is to assure that "configuration-setup" type messages * are also printed when NETCAM_DEBUG is set.  Set the following #if to * 1 to enable it, or 0 (normal setting) to disable it. */#define SETUP    ((cnt->conf.setup_mode) || (debug_level >= CAMERA_INFO))/* These strings are used for the HTTP connection */static const char    *connect_req = "GET %s HTTP/1.0\r\n"                      "Host: %s\r\n"                      "User-Agent: Motion-netcam/" VERSION "\r\n"                      "Connection: close\r\n";static const char    *connect_auth_req = "Authorization: Basic %s\r\n";/* * The following three routines (netcam_url_match, netcam_url_parse and * netcam_url_free are for 'parsing' (i.e. separating into the relevant * components) the URL provided by the user.  They make use of regular * expressions (which is outside the scope of this module, so detailed * comments are not provided).  netcam_url_parse is called from netcam_start, * and puts the "broken-up" components of the URL into the "url" element of * the netcam_context structure. * * Note that the routines are not "very clever", but they work sufficiently * well for the limited requirements of this module.  The expression: *   (http)://(((.*):(.*))@)?([^/:]|[-.a-z0-9]+)(:([0-9]+))?($|(/[^:]*)) * requires *   1) a string which begins with 'http', followed by '://' *   2) optionally a '@' which is preceded by two strings *      (with 0 or more characters each) separated by a ':' *      [this is for an optional username:password] *   3) a string comprising alpha-numerics, '-' and '.' characters *      [this is for the hostname] *   4) optionally a ':' followed by one or more numeric characters *      [this is for an optional port number] *   5) finally, either an end of line or a series of segments, *      each of which begins with a '/', and contains anything *      except a ':' *//** * netcam_url_match * *      Finds the matched part of a regular expression * * Parameters: * *      m          A structure containing the regular expression to be used *      input      The input string * * Returns:        The string which was matched * */static char *netcam_url_match(regmatch_t m, const char *input){	char *match = NULL;	int len;	if (m.rm_so != -1) {		len = m.rm_eo - m.rm_so;		if ((match = (char *) malloc(len + 1)) != NULL) {			strncpy(match, input + m.rm_so, len);			match[len] = '\0';		}	}	return (match);}/** * netcam_url_parse * *      parses a string containing a URL into it's components * * Parameters: *      parse_url          A structure which will receive the results *                         of the parsing *      text_url           The input string containing the URL * * Returns:                Nothing * */static void netcam_url_parse(struct url_t *parse_url, const char *text_url){	char *s;	int i;	const char *re = "(http|ftp)://(((.*):(.*))@)?"	                 "([^/:]|[-.a-z0-9]+)(:([0-9]+))?($|(/[^:]*))";	regex_t pattbuf;	regmatch_t matches[10];	memset(parse_url, 0, sizeof(struct url_t));	/*	 * regcomp compiles regular expressions into a form that is	 * suitable for regexec searches	 * regexec matches the URL string against the regular expression	 * and returns an array of pointers to strings matching each match	 * within (). The results that we need are finally placed in parse_url	 */	if (!regcomp(&pattbuf, re, REG_EXTENDED | REG_ICASE)) {		if (regexec(&pattbuf, text_url, 10, matches, 0) != REG_NOMATCH) {			for (i = 0; i < 10; i++) {				if ((s = netcam_url_match(matches[i], text_url)) != NULL) {					switch (i) {						case 1:							parse_url->service = s;							break;						case 3:							parse_url->userpass = s;							break;						case 6:							parse_url->host = s;							break;						case 8:							parse_url->port = atoi(s);							free(s);							break;						case 9:							parse_url->path = s;							break;						/* other components ignored */						default:							free(s);							break;					}				}			}		}	}	if ((!parse_url->port) && (parse_url->service)){		if (!strcmp(parse_url->service, "http"))			parse_url->port = 80;		else if (!strcmp(parse_url->service, "ftp"))			parse_url->port = 21;	}	regfree(&pattbuf);}/** * netcam_url_free * *      General cleanup of the URL structure, called from netcam_cleanup. * * Parameters: * *      parse_url       Structure containing the parsed data * * Returns:             Nothing * */static void netcam_url_free(struct url_t *parse_url){	if (parse_url->service) {		free(parse_url->service);		parse_url->service = NULL;	}	if (parse_url->userpass) {		free(parse_url->userpass);		parse_url->userpass = NULL;	}	if (parse_url->host) {		free(parse_url->host);		parse_url->host = NULL;	}	if (parse_url->path) {		free(parse_url->path);		parse_url->path = NULL;	}}/** * check_quote * *      Checks a string to see if it's quoted, and if so removes the *      quotes. * * Parameters: * *      str             Pointer to a string * * Returns:             Nothing, but updates the target if necessary * */static void check_quote(char *str){	int len;	char ch;	ch = *str;	if ((ch == '"') || (ch == '\'')) {		len = strlen(str) - 1;		if (str[len] == ch) {			memmove(str, str+1, len-1);			str[len-1] = 0;		}	}}/** * netcam_check_content_length * * 	Analyse an HTTP-header line to see if it is a Content-length * * Parameters: * *      header          Pointer to a string containing the header line * * Returns: *      -1              Not a Content-length line *      >=0             Value of Content-length field * */static long netcam_check_content_length(char *header){	long length=-1;	/* note this is a long, not an int */	if (!header_process(header, "Content-Length", header_extract_number, &length)) {		/*		 * Some netcams deliver some bad-format data, but if		 * we were able to recognize the header section and the		 * number we might as well try to use it.		 */		if (length > 0)			return length;		return -1;	}	return length;}/** * netcam_check_content_type * * 	Analyse an HTTP-header line to see if it is a Content-type * * Parameters: * *      header          Pointer to a string containing the header line * * Returns: *      -1              Not a Content-type line *      0               Content-type not recognized *      1               image/jpeg *      2               multipart/x-mixed-replace or multipart/mixed * */static int netcam_check_content_type(char *header){	char *content_type = NULL;	int ret;	if (!header_process(header, "Content-type", http_process_type, &content_type))		return -1;	if (!strcmp(content_type, "image/jpeg")) {		ret = 1;	} else if (!strcmp(content_type, "multipart/x-mixed-replace") ||	           !strcmp(content_type, "multipart/mixed")) {		ret = 2;	} else		ret = 0;	if (content_type)		free(content_type);	return ret;}/** * netcam_read_next_header * *      Read the next header record from the camera. * * Parameters * *      netcam          pointer to a netcam_context * * Returns:             0 for success, -1 if any error * */static int netcam_read_next_header(netcam_context_ptr netcam){	int retval;	char *header;	/*	 * return if not connected	 */	if (netcam->sock == -1) return -1;	/*	 * We are expecting a header which *must* contain a mime-type of	 * image/jpeg, and *might* contain a Content-Length.	 *	 * If this is a "streaming" camera, the header *must* be preceded	 * by a "boundary" string.	 *	 */	netcam->caps.content_length = 0;	/*	 * If this is a "streaming" camera, the stream header must be	 * preceded by a "boundary" string	 */	if (netcam->caps.streaming) {		while (1) {			retval = header_get(netcam, &header, HG_NONE);			if (retval != HG_OK) {				motion_log(LOG_ERR, 0, "Error reading image header");				free(header);				return -1;			}			retval = (strstr(header, netcam->boundary) == NULL);			free(header);			if (!retval)				break;		}	}	while (1) {		retval = header_get(netcam, &header, HG_NONE);		if (retval != HG_OK) {			motion_log(LOG_ERR, 0, "Error reading image header");			free(header);			return -1;		}		if (*header == 0)			break;		if ((retval = netcam_check_content_type(header)) >= 0) {			if (retval != 1) {				motion_log(LOG_ERR, 0, "Header not JPEG");				free(header);				return -1;			}		}		if ((retval = (int) netcam_check_content_length(header)) > 0) {			netcam->caps.content_length = 1;       /* set flag */			netcam->receiving->content_length = (int) retval;		}		free(header);	}	if (debug_level > CAMERA_INFO)		motion_log(-1, 0, "Found image header record");	free(header);	return 0;}/** * netcam_read_first_header * * This routine attempts to read a header record from the netcam.  If * successful, it analyses the header to determine whether the camera is * a "streaming" type.  If it is, the routine looks for the Boundary-string; * if found, it positions just past the string so that the image header can * be read.  It then reads the image header and continues processing that * header as well. * * If the camera does not appear to be a streaming type, it is assumed that the * header just read was the image header.  It is processed to determine whether * a Content-length is present. * * After this processing, the routine returns to the caller. * * Parameters: *      netcam            Pointer to the netcam_context structure * * Returns:               Content-type code if successful, -1 if not * */static int netcam_read_first_header(netcam_context_ptr netcam){	int retval = -2;                         /* "Unknown err" */	int ret;	int firstflag = 1;	char *header;	char *boundary;	struct context *cnt = netcam->cnt;       /* for conf debug_level */	/* Send the initial command to the camera */	if (send(netcam->sock, netcam->connect_request,	         strlen(netcam->connect_request), 0) < 0) {		motion_log(LOG_ERR, 1, "Error sending 'connect' request");		return -1;	}	/*	 * We expect to get back an HTTP header from the camera.	 * Successive calls to header_get will return each line	 * of the header received.  We will continue reading until	 * a blank line is received.	 *	 * As we process the header, we are looking for either of	 * header lines Content-type or Content-length.  Content-type	 * is used to determine whether the camera is "streaming" or	 * "non-streaming", and Content-length will be used to determine	 * whether future reads of images will be controlled by the	 * length specified before the image, or by a boundary string.	 *	 * The Content-length will only be present "just before" an	 * image is sent (if it is present at all).  That means that, if	 * this is a "streaming" camera, it will not be present in the	 * "first header", but will occur later (after a boundary-string).	 * For a non-streaming camera, however, there is no boundary-string,	 * and the first header is, in fact, the only header.  In this case,	 * there may be a Content-length.	 *	 */	while (1) {                                 /* 'Do forever' */		ret = header_get(netcam, &header, HG_NONE);		if (ret != HG_OK) {			if (debug_level > 5)				motion_log(LOG_ERR, 0, "Error reading first header (%s)", header);			free(header);