netcam.c

motion motion

			}
			continue;
		}
		/*
		 * FIXME
		 * Need to check whether the image was received / decoded
		 * satisfactorily
		 */

		/*
		 * If non-streaming, want to synchronize our thread with the
		 * motion main-loop.
		 */
		if (!netcam->caps.streaming) {
			pthread_mutex_lock(&netcam->mutex);

			/* before anything else, check for system shutdown */
			if (netcam->finish) {
				pthread_mutex_unlock(&netcam->mutex);
				break;
			}

			/*
			 * If our current loop has finished before the next
			 * request from the motion main-loop, we do a
			 * conditional wait (wait for signal).  On the other
			 * hand, if the motion main-loop has already signalled
			 * us, we just continue.  In either event, we clear
			 * the start_capture flag set by the main loop.
			 */
			if (!netcam->start_capture)
				pthread_cond_wait(&netcam->cap_cond, &netcam->mutex);

			netcam->start_capture = 0;

			pthread_mutex_unlock(&netcam->mutex);
		}
	/* the loop continues forever, or until motion shutdown */
	}

	/* our thread is finished - decrement motion's thread count */
	pthread_mutex_lock(&global_lock);
	threads_running--;
	pthread_mutex_unlock(&global_lock);

	/* log out a termination message */
	motion_log(LOG_INFO, 0, "netcam camera handler: finish set, exiting");

	/* setting netcam->thread_id to zero shows netcam_cleanup we're done */
	netcam->thread_id = 0;

	/* signal netcam_cleanup that we're all done */
	pthread_mutex_lock(&netcam->mutex);
	pthread_cond_signal(&netcam->exiting);
	pthread_mutex_unlock(&netcam->mutex);

	/* Goodbye..... */
	pthread_exit(NULL);
}

static int netcam_setup_html(netcam_context_ptr netcam, struct url_t *url) {
	struct context *cnt = netcam->cnt;
	const char *ptr;                  /* working var */
	char *userpass;                   /* temp pointer to config value */
	char *encuserpass;                /* temp storage for encoded ver */
	char *request_pass = NULL;        /* temp storage for base64 conv */
	int ix;

	/* First the http context structure */
	netcam->response = (struct rbuf *) mymalloc(sizeof(struct rbuf));
	memset(netcam->response, 0, sizeof(struct rbuf));

	if (debug_level > CAMERA_INFO)
		motion_log(LOG_INFO, 0, "netcam_setup_html: Netcam has flags: HTTP1.0: %s HTTP1.1: %s Keep-Alive %s.", 
		                        netcam->connect_http_10 ? "1":"0", netcam->connect_http_11 ? "1":"0", 
		                        netcam->connect_keepalive ? "ON":"OFF");

	/*
	 * The network camera may require a username and password.  If
	 * so, the information can come from two different places in the
	 * motion configuration file.  Either it can be present in
	 * the netcam_userpass, or it can be present as a part of the URL
	 * for the camera.  We assume the first of these has a higher
	 * relevance.
	 */
	if (cnt->conf.netcam_userpass)
		ptr = cnt->conf.netcam_userpass;
	else
		ptr = url->userpass;

	/* base64_encode needs up to 3 additional chars */
	if (ptr) {
		userpass = mymalloc(strlen(ptr) + 3);
		strcpy(userpass, ptr);
	} else
		userpass = NULL;

	/*
	 * Now we want to create the actual string which will be used to
	 * connect to the camera.  It may or may not contain a username /
	 * password.  We first compose a basic connect message, then check
	 * if a Keep-Alive header is to be included (or just 'close'), then
	 * whether a username / password is required and, if so, just
	 * concatenate it with the request.
	 *
	 */
	/* space for final \r\n plus string terminator */
	ix = 3;

	/* See if username / password is required */
	if (userpass) {         /* if either of the above are non-NULL */
		/* Allocate space for the base64-encoded string */
		encuserpass = mymalloc(BASE64_LENGTH(strlen(userpass)) + 1);
		/* Fill in the value */
		base64_encode(userpass, encuserpass, strlen(userpass));
		/* Now create the last part (authorization) of the request */
		request_pass = mymalloc(strlen(connect_auth_req) +
		                        strlen(encuserpass) + 1);
		ix += sprintf(request_pass, connect_auth_req, encuserpass);
		/* free the working variables */
		free(encuserpass);
	}

	/*
	 * We are now ready to set up the netcam's "connect request".  Most of
	 * this comes from the (preset) string 'connect_req', but additional
	 * characters are required if there is a proxy server, or if there is
	 * a Keep-Alive connection rather than a close connection, or
	 * a username / password for the camera.  The variable 'ix' currently
	 * has the number of characters required for username/password (which
	 * could be zero) and for the \r\n and string terminator.  We will also
	 * always need space for the netcam path, and if a proxy is being used
	 * we also need space for a preceding  'http://{hostname}' for the
	 * netcam path.
	 * Note: Keep-Alive (but not HTTP 1.1) is disabled if a proxy URL
	 * is set, since HTTP 1.0 Keep-alive cannot be transferred through.
	 */
	if (cnt->conf.netcam_proxy) {
		/*
		 * Allocate space for a working string to contain the path.
		 * The extra 4 is for "://" and string terminator.
		 */
		ptr = mymalloc(strlen(url->service) + strlen(url->host)
		               + strlen(url->path) + 4);
		sprintf((char *)ptr, "http://%s%s", url->host, url->path);
	        netcam->connect_keepalive=0; /* Disable Keepalive if proxy */
		if (debug_level > CAMERA_INFO)
			motion_log(LOG_DEBUG, 0, "Removed netcam_keepalive flag due to proxy set." 
			                         "Proxy is incompatible with Keep-Alive.");
	} else {
		/* if no proxy, set as netcam_url path */
		ptr = url->path;
		/*
		 * after generating the connect message the string
		 * will be freed, so we don't want netcam_url_free
		 * to free it as well.
		 */
		url->path = NULL;
	}

	ix += strlen(ptr);

       /* Now add the required number of characters for the close header
        * or Keep-Alive header.  We test the flag which can be unset if
	* there is a problem (rather than the flag in the conf structure
	* which is read-only.
	*/
 
        if (netcam->connect_keepalive) {
		ix += strlen(connect_req_keepalive);
	} else {
		ix += strlen(connect_req_close);
	}

	/* Point to either the HTTP 1.0 or 1.1 request header set     */
	/* If the configuration is anything other than 1.1, use 1.0   */
	/* as a default. This avoids a chance of being left with none */
	if (netcam->connect_http_11==TRUE)
		connect_req = connect_req_http11;
	else
		connect_req = connect_req_http10;

	/*
	 * Now that we know how much space we need, we can allocate space
	 * for the connect-request string.
	 */
	netcam->connect_request = mymalloc(strlen(connect_req) + ix +
	                          strlen(netcam->connect_host));

	/* Now create the request string with an sprintf */
	sprintf(netcam->connect_request, connect_req, ptr,
	        netcam->connect_host); 

        if (netcam->connect_keepalive) { 
		strcat(netcam->connect_request, connect_req_keepalive);
	} else {
		strcat(netcam->connect_request, connect_req_close);
	}

	if (userpass) {
		strcat(netcam->connect_request, request_pass);
		free(request_pass);
		free(userpass);
	}

	/* put on the final CRLF onto the request */
	strcat(netcam->connect_request, "\r\n");
	free((void *)ptr);
	netcam_url_free(url);         /* Cleanup the url data */

	if (debug_level > CAMERA_INFO) {
		motion_log(-1, 0, "Camera connect string is ''%s''", netcam->connect_request);
		motion_log(-1, 0, "End of camera connect string.");
	}

	/*
	 * Our basic initialisation has been completed.  Now we will attempt
	 * to connect with the camera so that we can then get a "header"
	 * in order to find out what kind of camera we are dealing with,
	 * as well as what are the picture dimensions.  Note that for
	 * this initial connection, any failure will cause an error
	 * return from netcam_start (unlike later possible attempts at
	 * re-connecting, if the network connection is later interrupted).
	 */
	for (ix = 0; ix < MAX_HEADER_RETRIES; ix++) {
		/*
		 * netcam_connect does an automatic netcam_close, so it's
		 * safe to include it as part of this loop
		 * (Not always true now Keep-Alive is implemented)
		 */
		if (debug_level > CAMERA_INFO)
			motion_log(-1, 0, "netcam_setup_html: about to try to connect, time #%d", ix );
		if (netcam_connect(netcam, 0) != 0) {
			motion_log(LOG_ERR, 0,"Failed to open camera - check your config and that netcamera is online");

			/* Fatal error on startup */
			ix = MAX_HEADER_RETRIES;
			break;;
		}

		if (netcam_read_first_header(netcam) >= 0)
			break;

		motion_log(LOG_ERR, 0, "Error reading first header - re-trying");
	}

	if (ix == MAX_HEADER_RETRIES) {
		motion_log(LOG_ERR, 0, "Failed to read first camera header - giving up for now");
		return -1;
	}

	/*
	 * If this is a streaming camera, we need to position just
	 * past the boundary string and read the image header
	 */
	if (netcam->caps.streaming) {
		if (netcam_read_next_header(netcam) < 0) {
			motion_log(LOG_ERR, 0,
			           "Failed to read first stream header - giving up for now");
			return -1;
		}
	}

	if (debug_level > CAMERA_INFO)
		motion_log(-1, 0, "netcam_setup_html: connected, going on to read image.", ix );
	netcam->get_image = netcam_read_html_jpeg;
	return 0;
}

static int netcam_setup_ftp(netcam_context_ptr netcam, struct url_t *url) {
	struct context *cnt = netcam->cnt;
	const char *ptr;

	if ((netcam->ftp = ftp_new_context()) == NULL)
		return -1;
	/*
	 * We copy the strings out of the url structure into the ftp_context
	 * structure.  By setting url->{string} to NULL we effectively "take
	 * ownership" of the string away from the URL (i.e. it won't be freed
	 * when we cleanup the url structure later).
	 */
	netcam->ftp->path = url->path;
	url->path = NULL;

	if (cnt->conf.netcam_userpass != NULL)
		ptr = cnt->conf.netcam_userpass;
	else {
		ptr = url->userpass;  /* don't set this one NULL, gets freed */
	}

	if (ptr != NULL) {
		char *cptr;

		if ((cptr = strchr(ptr, ':')) == NULL)
			netcam->ftp->user = strdup(ptr);
		else {
			netcam->ftp->user = mymalloc((cptr - ptr));
			memcpy(netcam->ftp->user,ptr,(cptr - ptr));
			netcam->ftp->passwd = strdup(cptr + 1);
		}
	}

	netcam_url_free(url);

	/*
	 * The ftp context should be all ready to attempt a connection with
	 * the server, so we try ....
	 */
	if (ftp_connect(netcam) < 0) {
		ftp_free_context(netcam->ftp);
		return -1;
	}

	if (ftp_send_type(netcam->ftp, 'I') < 0) {
		motion_log(LOG_ERR, 0, "Error sending TYPE I to ftp server");
		return -1;
	}

	netcam->get_image = netcam_read_ftp_jpeg;
	return 0;
}

/**
 * netcam_recv
 *
 *      This routine receives the next block from the netcam.  It takes care
 *      of the potential timeouts and interrupt which may occur because of
 *      the settings from setsockopt.
 *
 * Parameters:
 *
 *      netcam          Pointer to a netcam context
 *      buffptr         Pointer to the receive buffer
 *      buffsize        Length of the buffer
 *
 * Returns:
 *      If successful, the length of the message received, otherwise the
 *      error reply from the system call.
 *
 */
ssize_t netcam_recv(netcam_context_ptr netcam, void *buffptr, size_t buffsize) {
	ssize_t retval;
	fd_set fd_r;
	struct timeval selecttime;

	FD_ZERO(&fd_r);
	FD_SET(netcam->sock, &fd_r);
	selecttime = netcam->timeout;

	retval = select(FD_SETSIZE, &fd_r, NULL, NULL, &selecttime);
	if (retval == 0) {             /* 0 means timeout */
		return -1;
	}

	return recv(netcam->sock, buffptr, buffsize, 0);
}

/**
 * netcam_cleanup
 *
 *      This routine releases any allocated data within the netcam context,
 *      then frees the context itself.  Extreme care must be taken to assure
 *      that the multi-threading nature of the program is correctly
 *      handled.
 *      This function is also called from motion_init if first time connection
 *      fails and we start retrying until we get a valid first frame from the
 *      camera. 
 *
 * Parameters:
 *
 *      netcam           Pointer to a netcam context
 *      init_retry_flag  1 when the function is called because we are retrying
 *                         making the initial connection with a netcam and we know
 *                         we do not need to kill a netcam handler thread
 *                       0 in any other case.
 *
 * Returns:              Nothing.
 *
 */
void netcam_cleanup(netcam_context_ptr netcam, int init_retry_flag)
{
	struct timespec waittime;

	if (!netcam)
		return;

	/*
	 * This 'lock' is just a bit of "defensive" programming.  It should
	 * only be necessary if the routine is being called from different
	 * threads, but in our Motion design, it should only be called from
	 * the motion main-loop.
	 */
	pthread_mutex_lock(&netcam->mutex);

	if (netcam->cnt->netcam == NULL) {
		return;
	}

	/*
	 * We set the netcam_context pointer in the motion main-loop context
	 * to be NULL, so that this routine won't be called a second time
	 */
	netcam->cnt->netcam = NULL;

	/*
	 * Next we set 'finish' in order to get the camera-handler thread
	 * to stop.
	 */
	netcam->finish = 1;

	/*
	 * If the camera is non-streaming, the handler thread could be waiting
	 * for a signal, so we send it one.  If it's actually waiting on the
	 * condition, it won't actually start yet because we still have
	 * netcam->mutex locked.
	 */

	if (!netcam