src/zm_remote_camera_http.cpp
Rama master · réplica de lectura del repositorio original.
//
// ZoneMinder Remote Camera Class Implementation, $Date$, $Revision$
// Copyright (C) 2001-2008 Philip Coombes
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
#include "zm_remote_camera_http.h"
#include "zm_monitor.h"
#include "zm_packet.h"
#include "zm_signal.h"
#include "zm_regexp.h"
#include "zm_utils.h"
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#ifdef SOLARIS
#include <sys/filio.h> // FIONREAD and friends
#endif
#ifdef __FreeBSD__
#include <netinet/in.h>
#endif
#if HAVE_LIBPCRE
static RegExpr *header_expr = nullptr;
static RegExpr *status_expr = nullptr;
static RegExpr *connection_expr = nullptr;
static RegExpr *content_length_expr = nullptr;
static RegExpr *content_type_expr = nullptr;
#endif
RemoteCameraHttp::RemoteCameraHttp(
const Monitor *monitor,
const std::string &p_method,
const std::string &p_host,
const std::string &p_port,
const std::string &p_path,
const std::string &p_user,
const std::string &p_pass,
int p_width, int p_height,
int p_colours,
int p_brightness,
int p_contrast,
int p_hue,
int p_colour,
bool p_capture,
bool p_record_audio ) :
RemoteCamera(
monitor,
"http",
p_host,
p_port,
p_path,
p_user,
p_pass,
p_width,
p_height,
p_colours,
p_brightness,
p_contrast,
p_hue,
p_colour,
p_capture,
p_record_audio ) {
sd = -1;
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if ( p_method == "simple" )
method = SIMPLE;
else if ( p_method == "regexp" ) {
method = REGEXP;
} else
Fatal("Unrecognised method '%s' when creating HTTP camera %d", p_method.c_str(), monitor->Id());
if ( capture ) {
Initialise();
}
mVideoStream = nullptr;
}
RemoteCameraHttp::~RemoteCameraHttp() {
if (capture and (sd != -1)) {
Terminate();
}
}
void RemoteCameraHttp::Initialise() {
RemoteCamera::Initialise();
if ( request.empty() ) {
request = stringtf( "GET %s HTTP/%s\r\n", path.c_str(), config.http_version );
request += stringtf( "User-Agent: %s/%s\r\n", config.http_ua, ZM_VERSION );
request += stringtf( "Host: %s\r\n", host.c_str());
if ( strcmp( config.http_version, "1.0" ) == 0 )
request += "Connection: Keep-Alive\r\n";
if ( !auth.empty() )
request += stringtf( "Authorization: Basic %s\r\n", auth64.c_str() );
request += "\r\n";
Debug( 2, "Request: %s", request_for_log(request).c_str() );
}
if ( !timeout.tv_sec ) {
timeout.tv_sec = config.http_timeout/1000;
timeout.tv_usec = (config.http_timeout%1000)*1000;
}
int max_size = width*height*colours;
buffer.size( max_size );
mode = SINGLE_IMAGE;
format = UNDEF;
state = HEADER;
#if HAVE_LIBPCRE
if ( method == REGEXP ) {
if ( !header_expr )
header_expr = new RegExpr("^(.+?\r?\n\r?\n)", PCRE2_DOTALL);
if ( !status_expr )
status_expr = new RegExpr("^HTTP/(1\\.[01]) +([0-9]+) +(.+?)\r?\n", PCRE2_CASELESS);
if ( !connection_expr )
connection_expr = new RegExpr("Connection: ?(.+?)\r?\n", PCRE2_CASELESS);
if ( !content_length_expr )
content_length_expr = new RegExpr("Content-length: ?([0-9]+)\r?\n", PCRE2_CASELESS);
if ( !content_type_expr )
content_type_expr = new RegExpr("Content-type: ?(.+?)(?:; ?boundary=\x22?(.+?)\x22?)?\r?\n", PCRE2_CASELESS);
}
#endif
} // end void RemoteCameraHttp::Initialise()
int RemoteCameraHttp::Connect() {
struct addrinfo *p = nullptr;
if (!hp) {
RemoteCamera::Initialise();
if (!hp) {
Error("Unable to resolve address for remote camera, aborting");
return -1;
}
}
for ( p = hp; p != nullptr; p = p->ai_next ) {
sd = socket( p->ai_family, p->ai_socktype, p->ai_protocol );
if ( sd < 0 ) {
Warning("Can't create socket: %s", strerror(errno) );
continue;
}
if ( connect( sd, p->ai_addr, p->ai_addrlen ) < 0 ) {
close(sd);
sd = -1;
char buf[INET6_ADDRSTRLEN];
struct sockaddr_in *addr;
addr = (struct sockaddr_in *)p->ai_addr;
inet_ntop(AF_INET, &(addr->sin_addr), buf, sizeof(buf));
Warning("Can't connect to remote camera mid: %d at %s: %s", monitor->Id(), buf, strerror(errno));
continue;
}
/* If we got here, we must have connected successfully */
break;
}
if ( p == nullptr ) {
Error("Unable to connect to the remote camera, aborting");
return -1;
}
Debug(3, "Connected to host, socket = %d", sd);
return sd;
} // end int RemoteCameraHttp::Connect()
int RemoteCameraHttp::Disconnect() {
if (sd != -1) {
close(sd);
sd = -1;
Debug(3, "Disconnected from host");
}
return 0;
}
int RemoteCameraHttp::SendRequest() {
Debug(2, "Sending request: %s", request_for_log(request).c_str());
if ( write(sd, request.data(), request.length()) < 0 ) {
Error("Can't write: %s", strerror(errno));
Disconnect();
return -1;
}
format = UNDEF;
state = HEADER;
Debug(3, "Request sent");
return 0;
}
/* Return codes are as follows:
* -1 means there was an error
* 0 means no bytes were returned but there wasn't actually an error.
* > 0 is the # of bytes read.
*/
int RemoteCameraHttp::ReadData(Buffer &buffer, unsigned int bytes_expected) {
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(sd, &rfds);
struct timeval temp_timeout = timeout;
int n_found = select(sd+1, &rfds, nullptr, nullptr, &temp_timeout);
if (n_found == 0) {
Debug(1, "Select timed out timeout was %" PRIi64 " secs %" PRIi64" usecs",
static_cast<int64>(temp_timeout.tv_sec),
static_cast<int64>(temp_timeout.tv_usec));
int error = 0;
socklen_t len = sizeof(error);
int retval = getsockopt(sd, SOL_SOCKET, SO_ERROR, &error, &len);
if (retval != 0) {
Debug(1, "error getting socket error code %s", strerror(errno));
}
if (error != 0) {
return -1;
}
// Why are we disconnecting? It's just a timeout, meaning that data wasn't available.
//Disconnect();
return 0;
} else if (n_found == EINTR) {
Error("Select interrupted");
return 0;
} else if (n_found < 0) {
Error("Select error: %s", strerror(errno));
return -1;
}
unsigned int total_bytes_to_read = 0;
if (bytes_expected) {
total_bytes_to_read = bytes_expected;
} else {
if (ioctl(sd, FIONREAD, &total_bytes_to_read) < 0) {
Error("Can't ioctl(): %s", strerror(errno) );
return -1;
}
if (total_bytes_to_read == 0) {
if (mode == SINGLE_IMAGE) {
int error = 0;
socklen_t len = sizeof(error);
int retval = getsockopt(sd, SOL_SOCKET, SO_ERROR, &error, &len);
if (retval != 0) {
Debug(1, "error getting socket error code %s", strerror(errno));
}
if (error != 0) {
return -1;
}
// Case where we are grabbing a single jpg, but no content-length was given, so the expectation is that we read until close.
return 0;
}
// If socket is closed locally, then select will fail, but if it is closed remotely
// then we have an exception on our socket.. but no data.
Debug(3, "Socket closed remotely");
//Disconnect(); // Disconnect is done outside of ReadData now.
return -1;
}
// There can be lots of bytes available. I've seen 4MB or more. This will vastly inflate our buffer size unnecessarily.
if (total_bytes_to_read > ZM_NETWORK_BUFSIZ) {
total_bytes_to_read = ZM_NETWORK_BUFSIZ;
Debug(4, "Just getting 32K");
} else {
Debug(4, "Just getting %d", total_bytes_to_read);
}
} // end if bytes_expected or not
Debug(4, "Expecting %d bytes", total_bytes_to_read);
int total_bytes_read = 0;
do {
int bytes_read = buffer.read_into(sd, total_bytes_to_read);
if (bytes_read < 0) {
Error("Read error: %s", strerror(errno));
return -1;
} else if (bytes_read == 0) {
Debug(2, "Socket closed");
//Disconnect(); // Disconnect is done outside of ReadData now.
return -1;
} else if ((unsigned int)bytes_read < total_bytes_to_read) {
Debug(1, "Incomplete read, expected %d, got %d", total_bytes_to_read, bytes_read);
} else {
Debug(3, "Read %d bytes", bytes_read);
}
total_bytes_read += bytes_read;
total_bytes_to_read -= bytes_read;
} while (total_bytes_to_read);
Debug(4, "buffer size: %d", static_cast<int>(buffer));
return total_bytes_read;
} // end readData
int RemoteCameraHttp::GetData() {
TimePoint start_time = std::chrono::steady_clock::now();
int buffer_len;
while (!(buffer_len = ReadData(buffer))) {
if (zm_terminate or std::chrono::steady_clock::now() - start_time > FPSeconds(config.watch_max_delay)) {
return -1;
}
Debug(4, "Timeout waiting for REGEXP HEADER");
std::this_thread::sleep_for(Milliseconds(100));
}
return buffer_len;
}
int RemoteCameraHttp::ParseContentLength(const char *text, unsigned long long image_size) {
// The length is read from the camera link, usually plain HTTP, and decides how much is
// buffered for one frame. No encoding of a frame is larger than twice its raw size, so a
// bigger length is refused instead of buffered. refs GHSA-x959-xrc9-89p8
constexpr unsigned long long kMaxContentLength = 1ull << 30;
const unsigned long long max_length =
std::min(kMaxContentLength, 2 * image_size + ZM_NETWORK_BUFSIZ);
if (!text) return -1;
while (*text == ' ') text++;
if (*text < '0' or *text > '9') return -1;
char *end = nullptr;
errno = 0;
const unsigned long long length = strtoull(text, &end, 10);
if (errno == ERANGE or length > max_length) return -1;
return static_cast<int>(length);
}
int RemoteCameraHttp::GetResponse() {
#if HAVE_LIBPCRE
if ( method == REGEXP ) {
const char *header = nullptr;
int header_len = 0;
const char *http_version = nullptr;
int status_code = 0;
const char *status_mesg = nullptr;
const char *connection_type = "";
int content_length = 0;
const char *content_type = "";
const char *content_boundary = "";
const char *subheader = nullptr;
int subheader_len = 0;
//int subcontent_length = 0;
//const char *subcontent_type = "";
while ( !zm_terminate ) {
switch( state ) {
case HEADER : {
int buffer_len = GetData();
if ( buffer_len < 0 ) {
Error("Unable to read header data");
return -1;
}
bytes += buffer_len;
if ( header_expr->Match( (char*)buffer, buffer.size() ) == 2 ) {
header = header_expr->MatchString( 1 );
header_len = header_expr->MatchLength( 1 );
Debug(4, "Captured header (%d bytes):\n'%s'", header_len, header);
if ( status_expr->Match( header, header_len ) < 4 ) {
Error( "Unable to extract HTTP status from header" );
return( -1 );
}
http_version = status_expr->MatchString( 1 );
status_code = atoi( status_expr->MatchString( 2 ) );
status_mesg = status_expr->MatchString( 3 );
if ( status_code == 401 ) {
if ( mNeedAuth ) {
Error( "Failed authentication: " );
return( -1 );
}
mNeedAuth = true;
std::string Header = header;
mAuthenticator->checkAuthResponse(Header);
if ( mAuthenticator->auth_method() == zm::AUTH_DIGEST ) {
Debug( 2, "Need Digest Authentication" );
request = stringtf( "GET %s HTTP/%s\r\n", path.c_str(), config.http_version );
request += stringtf( "User-Agent: %s/%s\r\n", config.http_ua, ZM_VERSION );
request += stringtf( "Host: %s\r\n", host.c_str());
if ( strcmp( config.http_version, "1.0" ) == 0 )
request += "Connection: Keep-Alive\r\n";
request += mAuthenticator->getAuthHeader("GET", path);
request += "\r\n";
Debug( 2, "New request header: %s", request_for_log(request).c_str() );
return( 0 );
}
} else if ( status_code < 200 || status_code > 299 ) {
Error( "Invalid response status %d: %s\n%s", status_code, status_mesg, (char *)buffer );
return( -1 );
}
Debug( 3, "Got status '%d' (%s), http version %s", status_code, status_mesg, http_version );
if ( connection_expr->Match( header, header_len ) == 2 ) {
connection_type = connection_expr->MatchString( 1 );
Debug( 3, "Got connection '%s'", connection_type );
}
if ( content_length_expr->Match( header, header_len ) == 2 ) {
content_length = ParseContentLength(content_length_expr->MatchString(1), imagesize);
if (content_length < 0) {
Error("Invalid content length '%s'", content_length_expr->MatchString(1));
return -1;
}
Debug( 3, "Got content length '%d'", content_length );
}
if ( content_type_expr->Match( header, header_len ) >= 2 ) {
content_type = content_type_expr->MatchString( 1 );
Debug( 3, "Got content type '%s'\n", content_type );
if ( content_type_expr->MatchCount() > 2 ) {
content_boundary = content_type_expr->MatchString( 2 );
Debug( 3, "Got content boundary '%s'", content_boundary );
}
}
if ( !strcasecmp( content_type, "image/jpeg" ) || !strcasecmp( content_type, "image/jpg" ) ) {
// Single image
mode = SINGLE_IMAGE;
format = JPEG;
state = CONTENT;
} else if ( !strcasecmp( content_type, "application/octet-stream" ) ) {
// Single image
mode = SINGLE_IMAGE;
format = JPEG;
state = CONTENT;
} else if ( !strcasecmp( content_type, "image/x-rgb" ) ) {
// Single image
mode = SINGLE_IMAGE;
format = X_RGB;
state = CONTENT;
} else if ( !strcasecmp( content_type, "image/x-rgbz" ) ) {
// Single image
mode = SINGLE_IMAGE;
format = X_RGBZ;
state = CONTENT;
} else if ( !strcasecmp( content_type, "multipart/x-mixed-replace" ) ) {
// Image stream, so start processing
if ( !content_boundary[0] ) {
Error( "No content boundary found in header '%s'", header );
return( -1 );
}
mode = MULTI_IMAGE;
state = SUBHEADER;
}
//else if ( !strcasecmp( content_type, "video/mpeg" ) || !strcasecmp( content_type, "video/mpg" ) )
//{
//// MPEG stream, coming soon!
//}
else {
Error("Unrecognised content type '%s'", content_type);
return -1;
}
buffer.consume(header_len);
} else {
Debug(3, "Unable to extract header from stream, retrying");
//return( -1 );
}
break;
}
case SUBHEADER : {
static RegExpr *subheader_expr = nullptr;
static RegExpr *subcontent_length_expr = nullptr;
static RegExpr *subcontent_type_expr = nullptr;
if ( !subheader_expr ) {
char subheader_pattern[256] = "";
snprintf( subheader_pattern, sizeof(subheader_pattern), "^((?:\r?\n){0,2}?(?:--)?%s\r?\n.+?\r?\n\r?\n)", content_boundary );
subheader_expr = new RegExpr( subheader_pattern, PCRE2_DOTALL );
}
if ( subheader_expr->Match( (char *)buffer, (int)buffer ) == 2 ) {
subheader = subheader_expr->MatchString( 1 );
subheader_len = subheader_expr->MatchLength( 1 );
Debug( 4, "Captured subheader (%d bytes):'%s'", subheader_len, subheader );
if ( !subcontent_length_expr )
subcontent_length_expr = new RegExpr( "Content-length: ?([0-9]+)\r?\n", PCRE2_CASELESS );
if ( subcontent_length_expr->Match( subheader, subheader_len ) == 2 ) {
content_length = ParseContentLength(subcontent_length_expr->MatchString(1), imagesize);
if (content_length < 0) {
Error("Invalid subcontent length '%s'", subcontent_length_expr->MatchString(1));
return -1;
}
Debug( 3, "Got subcontent length '%d'", content_length );
}
if ( !subcontent_type_expr )
subcontent_type_expr = new RegExpr( "Content-type: ?(.+?)\r?\n", PCRE2_CASELESS );
if ( subcontent_type_expr->Match( subheader, subheader_len ) == 2 ) {
content_type = subcontent_type_expr->MatchString( 1 );
Debug( 3, "Got subcontent type '%s'", content_type );
}
buffer.consume( subheader_len );
state = CONTENT;
} else {
Debug( 3, "Unable to extract subheader from stream, retrying" );
int buffer_len = GetData();
if ( buffer_len < 0 ) {
Error( "Unable to extract subheader data" );
return( -1 );
}
bytes += buffer_len;
}
break;
}
case CONTENT : {
// if content_type is something like image/jpeg;size=, this will strip the ;size=
char * semicolon = strchr( (char *)content_type, ';' );
if ( semicolon ) {
*semicolon = '\0';
}
if ( !strcasecmp( content_type, "image/jpeg" ) || !strcasecmp( content_type, "image/jpg" ) ) {
format = JPEG;
} else if ( !strcasecmp( content_type, "application/octet-stream" ) ) {
format = JPEG;
} else if ( !strcasecmp( content_type, "image/x-rgb" ) ) {
format = X_RGB;
} else if ( !strcasecmp( content_type, "image/x-rgbz" ) ) {
format = X_RGBZ;
} else {
Error( "Found unsupported content type '%s'", content_type );
return( -1 );
}
if (content_length) {
while (((long)buffer.size() < content_length ) and !zm_terminate) {
Debug(3, "Need more data buffer %d < content length %d", buffer.size(), content_length);
int bytes_read = ReadData(buffer, content_length - buffer.size());
if (bytes_read < 0) {
Error("Unable to read content");
return -1;
}
bytes += bytes_read;
}
Debug(3, "Got end of image by length, content-length = %d", content_length);
} else {
while (!content_length) {
int buffer_len = GetData();
if (buffer_len < 0) {
Error("Unable to read content");
return -1;
}
bytes += buffer_len;
static RegExpr *content_expr = 0;
if (mode == MULTI_IMAGE) {
if (!content_expr) {
char content_pattern[256] = "";
snprintf(content_pattern, sizeof(content_pattern), "^(.+?)(?:\r?\n)*(?:--)?%s\r?\n", content_boundary);
content_expr = new RegExpr(content_pattern, PCRE2_DOTALL);
}
if (content_expr->Match( buffer, buffer.size()) == 2) {
content_length = content_expr->MatchLength( 1 );
Debug(3, "Got end of image by pattern, content-length = %d", content_length);
}
}
}
}
if ( mode == SINGLE_IMAGE ) {
state = HEADER;
Disconnect();
} else {
state = SUBHEADER;
}
Debug( 3, "Returning %d (%d) bytes of captured content", content_length, buffer.size() );
return content_length;
}
case HEADERCONT :
case SUBHEADERCONT :
// Ignore
break;
}
}
} else
#endif // HAVE_LIBPCRE
{
static const char *http_match = "HTTP/";
static const char *connection_match = "Connection:";
static const char *content_length_match = "Content-length:";
static const char *content_type_match = "Content-type:";
static const char *boundary_match = "boundary=";
static const char *authenticate_match = "WWW-Authenticate:";
static int http_match_len = 0;
static int connection_match_len = 0;
static int content_length_match_len = 0;
static int content_type_match_len = 0;
static int boundary_match_len = 0;
static int authenticate_match_len = 0;
if ( !http_match_len )
http_match_len = strlen(http_match);
if ( !connection_match_len )
connection_match_len = strlen(connection_match);
if ( !content_length_match_len )
content_length_match_len = strlen(content_length_match);
if ( !content_type_match_len )
content_type_match_len = strlen(content_type_match);
if ( !boundary_match_len )
boundary_match_len = strlen(boundary_match);
if ( !authenticate_match_len )
authenticate_match_len = strlen(authenticate_match);
static int n_headers;
static int n_subheaders;
static char *http_header;
static char *connection_header;
static char *content_length_header;
static char *content_type_header;
static char *boundary_header;
static char *authenticate_header;
static char subcontent_length_header[33];
static char subcontent_type_header[65];
static char http_version[16];
static char status_code[16];
static char status_mesg[256];
static char connection_type[32];
static int content_length;
static char content_type[32];
static char content_boundary[64];
static int content_boundary_len;
while (!zm_terminate) {
switch (state) {
case HEADER :
n_headers = 0;
http_header = nullptr;
connection_header = nullptr;
content_length_header = nullptr;
content_type_header = nullptr;
authenticate_header = nullptr;
http_version[0] = '\0';
status_code [0]= '\0';
status_mesg [0]= '\0';
connection_type [0]= '\0';
content_length = 0;
content_type[0] = '\0';
content_boundary[0] = '\0';
content_boundary_len = 0;
FALLTHROUGH;
case HEADERCONT : {
int buffer_len = GetData();
if (buffer_len < 0) {
Error("Unable to read header");
return -1;
}
bytes += buffer_len;
char *crlf = nullptr;
char *header_ptr = buffer;
int header_len = buffer.size();
bool all_headers = false;
while (!zm_terminate) {
int crlf_len = memspn(header_ptr, "\r\n", header_len);
if (n_headers) {
if (
(crlf_len == 2 && !strncmp(header_ptr, "\n\n", crlf_len))
||
(crlf_len == 4 && !strncmp(header_ptr, "\r\n\r\n", crlf_len))
) {
Debug(3, "Have double linefeed, done headers");
*header_ptr = '\0';
header_ptr += crlf_len;
header_len -= buffer.consume(header_ptr-(char *)buffer);
all_headers = true;
break;
}
}
if (crlf_len) {
if (header_len == crlf_len) {
break;
} else {
*header_ptr = '\0';
header_ptr += crlf_len;
header_len -= buffer.consume(header_ptr-(char *)buffer);
}
}
Debug(6, "%s", header_ptr);
if ((crlf = mempbrk(header_ptr, "\r\n", header_len))) {
//headers[n_headers++] = header_ptr;
n_headers++;
if (!http_header && (strncasecmp(header_ptr, http_match, http_match_len) == 0)) {
http_header = header_ptr+http_match_len;
Debug(6, "Got http header '%s'", header_ptr);
} else if ( !connection_header && (strncasecmp(header_ptr, connection_match, connection_match_len) == 0) ) {
connection_header = header_ptr+connection_match_len;
Debug(6, "Got connection header '%s'", header_ptr);
} else if ( !content_length_header && (strncasecmp(header_ptr, content_length_match, content_length_match_len) == 0) ) {
content_length_header = header_ptr+content_length_match_len;
Debug(6, "Got content length header '%s'", header_ptr);
} else if ( !authenticate_header && (strncasecmp(header_ptr, authenticate_match, authenticate_match_len) == 0) ) {
authenticate_header = header_ptr;
Debug(6, "Got authenticate header '%s'", header_ptr);
} else if ( !content_type_header && (strncasecmp(header_ptr, content_type_match, content_type_match_len) == 0) ) {
content_type_header = header_ptr+content_type_match_len;
Debug(6, "Got content type header '%s'", header_ptr);
} else {
Debug(6, "Got ignored header '%s'", header_ptr);
}
header_ptr = crlf;
header_len -= buffer.consume(header_ptr-(char *)buffer);
} else {
// No end of line found
break;
}
} // end while search for headers
if (all_headers) {
char *start_ptr, *end_ptr;
if (!http_header) {
Error("Unable to extract HTTP status from header");
return -1;
}
start_ptr = http_header;
end_ptr = start_ptr+strspn(start_ptr, "10.");
zm_strncpy(http_version, start_ptr, sizeof(http_version), end_ptr-start_ptr);
start_ptr = end_ptr;
start_ptr += strspn(start_ptr, " ");
end_ptr = start_ptr+strspn(start_ptr, "0123456789");
zm_strncpy(status_code, start_ptr, sizeof(status_code), end_ptr-start_ptr);
int status = atoi(status_code);
start_ptr = end_ptr;
start_ptr += strspn(start_ptr, " ");
zm_strncpy(status_mesg, start_ptr, sizeof(status_mesg));
if (status == 401) {
if (mNeedAuth) {
Error("Failed authentication");
return -1;
}
if (!authenticate_header) {
Error("Failed authentication, but don't have an authentication header.");
return -1;
}
mNeedAuth = true;
std::string Header = authenticate_header;
Debug(2, "Checking for digest auth in %s", authenticate_header);
mAuthenticator->checkAuthResponse(Header);
if (mAuthenticator->auth_method() == zm::AUTH_DIGEST) {
Debug(2, "Need Digest Authentication");
request = stringtf("GET %s HTTP/%s\r\n", path.c_str(), config.http_version);
request += stringtf("User-Agent: %s/%s\r\n", config.http_ua, ZM_VERSION);
request += stringtf("Host: %s\r\n", host.c_str());
if ( strcmp(config.http_version, "1.0") == 0 )
request += "Connection: Keep-Alive\r\n";
request += mAuthenticator->getAuthHeader("GET", path);
request += "\r\n";
Debug(2, "New request header: %s", request_for_log(request).c_str());
return 0;
} else {
Debug(2, "Need some other kind of Authentication");
}
} else if (status < 200 || status > 299) {
Error("Invalid response status %s: %s", status_code, status_mesg);
return -1;
}
Debug(3, "Got status '%d' (%s), http version %s", status, status_mesg, http_version);
if (connection_header) {
start_ptr = connection_header + strspn(connection_header, " ");
zm_strncpy(connection_type, start_ptr, sizeof(connection_type));
Debug(3, "Got connection '%s'", connection_type);
}
if (content_length_header) {
start_ptr = content_length_header + strspn(content_length_header, " ");
content_length = ParseContentLength(start_ptr, imagesize);
if (content_length < 0) {
Error("Invalid content length '%.32s'", start_ptr);
return -1;
}
Debug(3, "Got content length '%d'", content_length);
}
if (content_type_header) {
//memset(content_type, 0, sizeof(content_type));
start_ptr = content_type_header + strspn(content_type_header, " ");
if ( (end_ptr = strchr(start_ptr, ';')) ) {
zm_strncpy(content_type, start_ptr, sizeof(content_type), end_ptr-start_ptr);
Debug(3, "Got content type '%s'", content_type);
start_ptr = end_ptr + strspn(end_ptr, "; ");
if (strncasecmp(start_ptr, boundary_match, boundary_match_len) == 0) {
start_ptr += boundary_match_len;
start_ptr += strspn(start_ptr, "-");
zm_strncpy(content_boundary, "--", sizeof(content_boundary));
zm_strncpy(content_boundary+2, start_ptr, sizeof(content_boundary)-2);
content_boundary_len = strlen(content_boundary);
Debug(3, "Got content boundary '%s'", content_boundary);
} else {
Error("No content boundary found in header '%s'", content_type_header);
}
} else {
zm_strncpy(content_type, start_ptr, sizeof(content_type));
Debug(3, "Got content type '%s'", content_type);
}
} // end if content_type_header
if (!strcasecmp(content_type, "image/jpeg") || !strcasecmp(content_type, "image/jpg")) {
// Single image
mode = SINGLE_IMAGE;
format = JPEG;
state = CONTENT;
} else if (!strcasecmp(content_type, "application/octet-stream")) {
// Single image
mode = SINGLE_IMAGE;
format = JPEG;
state = CONTENT;
} else if (!strcasecmp(content_type, "image/x-rgb")) {
// Single image
mode = SINGLE_IMAGE;
format = X_RGB;
state = CONTENT;
} else if (!strcasecmp(content_type, "image/x-rgbz")) {
// Single image
mode = SINGLE_IMAGE;
format = X_RGBZ;
state = CONTENT;
} else if (!strcasecmp(content_type, "multipart/x-mixed-replace")) {
// Image stream, so start processing
if (!content_boundary[0]) {
Error("No content boundary found in header '%s'", content_type_header);
return -1;
}
mode = MULTI_IMAGE;
state = SUBHEADER;
}
//else if ( !strcasecmp( content_type, "video/mpeg" ) || !strcasecmp( content_type, "video/mpg" ) )
//{
//// MPEG stream, coming soon!
//}
else {
Error("Unrecognised content type '%s'", content_type);
return -1;
}
} else {
Debug(3, "Unable to extract entire header from stream, continuing");
state = HEADERCONT;
//return( -1 );
} // end if all_headers
break;
}
case SUBHEADER :
n_subheaders = 0;
boundary_header = 0;
subcontent_length_header[0] = '\0';
subcontent_type_header[0] = '\0';
content_length = 0;
content_type[0] = '\0';
FALLTHROUGH;
case SUBHEADERCONT : {
char *crlf = nullptr;
char *subheader_ptr = (char *)buffer;
int subheader_len = buffer.size();
bool all_headers = false;
while (!zm_terminate) {
int crlf_len = memspn(subheader_ptr, "\r\n", subheader_len);
if (n_subheaders) {
if ((crlf_len == 2 && !strncmp(subheader_ptr, "\n\n", crlf_len))
||
(crlf_len == 4 && !strncmp(subheader_ptr, "\r\n\r\n", crlf_len))
) {
*subheader_ptr = '\0';
subheader_ptr += crlf_len;
subheader_len -= buffer.consume(subheader_ptr-(char *)buffer);
all_headers = true;
break;
}
}
if (crlf_len) {
if (subheader_len == crlf_len) {
break;
} else {
*subheader_ptr = '\0';
subheader_ptr += crlf_len;
subheader_len -= buffer.consume(subheader_ptr-(char *)buffer);
}
}
Debug(6, "%d: %s", subheader_len, subheader_ptr);
if ( (crlf = mempbrk(subheader_ptr, "\r\n", subheader_len)) ) {
//subheaders[n_subheaders++] = subheader_ptr;
n_subheaders++;
if ( !boundary_header && (strncasecmp(subheader_ptr, content_boundary, content_boundary_len) == 0) ) {
boundary_header = subheader_ptr;
Debug(4, "Got boundary subheader '%s'", subheader_ptr);
} else if (
!subcontent_length_header[0]
&&
(strncasecmp(subheader_ptr, content_length_match, content_length_match_len) == 0)
) {
strncpy(
subcontent_length_header,
subheader_ptr+content_length_match_len,
sizeof(subcontent_length_header)-1
);
*(subcontent_length_header+strcspn(subcontent_length_header, "\r\n")) = '\0';
Debug(4, "Got content length subheader '%s'", subcontent_length_header);
} else if ( !subcontent_type_header[0] && (strncasecmp( subheader_ptr, content_type_match, content_type_match_len) == 0) ) {
strncpy(
subcontent_type_header,
subheader_ptr+content_type_match_len,
sizeof(subcontent_type_header)-1
);
*(subcontent_type_header+strcspn(subcontent_type_header, "\r\n")) = '\0';
Debug(4, "Got content type subheader '%s'", subcontent_type_header);
} else {
Debug(6, "Got ignored subheader '%s' found", subheader_ptr);
}
subheader_ptr = crlf;
subheader_len -= buffer.consume( subheader_ptr-(char *)buffer );
} else {
// No line end found
break;
}
}
if (all_headers && boundary_header) {
char *start_ptr/*, *end_ptr*/;
Debug(3, "Got boundary '%s'", boundary_header);
if (subcontent_length_header[0]) {
start_ptr = subcontent_length_header + strspn(subcontent_length_header, " ");
content_length = ParseContentLength(start_ptr, imagesize);
if (content_length < 0) {
Error("Invalid subcontent length '%.32s'", start_ptr);
return -1;
}
Debug(3, "Got subcontent length '%d'", content_length);
}
if (subcontent_type_header[0]) {
//memset(content_type, 0, sizeof(content_type));
start_ptr = subcontent_type_header + strspn(subcontent_type_header, " ");
zm_strncpy(content_type, start_ptr, sizeof(content_type));
Debug(3, "Got subcontent type '%s'", content_type);
}
state = CONTENT;
} else {
Debug(3, "Unable to extract subheader from stream, retrying");
int buffer_len = GetData();
if (buffer_len < 0) {
Error("Unable to read subheader");
return -1;
}
bytes += buffer_len;
state = SUBHEADERCONT;
}
break;
}
case CONTENT : {
// if content_type is something like image/jpeg;size=, this will strip the ;size=
char * semicolon = strchr(content_type, ';');
if (semicolon) {
*semicolon = '\0';
}
if (!strcasecmp(content_type, "image/jpeg") || !strcasecmp(content_type, "image/jpg")) {
format = JPEG;
} else if (!strcasecmp(content_type, "application/octet-stream")) {
format = JPEG;
} else if (!strcasecmp(content_type, "image/x-rgb")) {
format = X_RGB;
} else if (!strcasecmp(content_type, "image/x-rgbz")) {
format = X_RGBZ;
} else {
Error("Found unsupported content type '%s'", content_type);
return -1;
}
// This is an early test for jpeg content, so we can bail early
if (format == JPEG and buffer.size() >= 2) {
if (buffer[0] != 0xff or buffer[1] != 0xd8) {
Error("Found bogus jpeg header '%02x%02x'", buffer[0], buffer[1]);
return -1;
}
}
if (content_length) {
while (((long)buffer.size() < content_length) and !zm_terminate) {
Debug(4, "getting more data");
int bytes_read = ReadData(buffer, content_length-buffer.size());
if (bytes_read < 0) {
Error("Unable to read content");
return -1;
}
bytes += bytes_read;
}
Debug(3, "Got end of image by length, content-length = %d", content_length);
} else {
// Read until we find the end of image or the stream closes.
while (!content_length && !zm_terminate) {
Debug(4, "!content_length, ReadData");
int buffer_len = ReadData(buffer);
if (buffer_len < 0) {
Error("Unable to read content");
return -1;
}
bytes += buffer_len;
int buffer_size = buffer.size();
if (buffer_len) {
// Got some data
if (mode == MULTI_IMAGE) {
// Look for the boundary marker, determine content length using it's position
if (const char *start_ptr = (char *)memstr( (char *)buffer, "\r\n--", buffer_size)) {
content_length = start_ptr - (char *)buffer;
Debug(2, "Got end of image by pattern (crlf--), content-length = %d", content_length);
} else {
Debug(2, "Did not find end of image by pattern (crlf--) yet, content-length = %d", content_length);
}
} // end if MULTI_IMAGE
} else {
content_length = buffer_size;
Debug(2, "Got end of image by closure, content-length = %d", content_length);
if (mode == SINGLE_IMAGE) {
char *end_ptr = (char *)buffer+buffer_size;
// strip off any last line feeds
while (*end_ptr == '\r' || *end_ptr == '\n') {
content_length--;
end_ptr--;
}
if (end_ptr != ((char *)buffer+buffer_size)) {
Debug(2, "Trimmed end of image, new content-length = %d", content_length);
}
} // end if SINGLE_IMAGE
} // end if read some data
} // end while ! content_length
} // end if content_length
if (mode == SINGLE_IMAGE) {
state = HEADER;
Disconnect();
} else {
state = SUBHEADER;
}
if (format == JPEG && buffer.size() >= 2) {
if (buffer[0] != 0xff || buffer[1] != 0xd8) {
Error("Found bogus jpeg header '%02x%02x'", buffer[0], buffer[1]);
return -1;
}
}
Debug(3, "Returning %d bytes, buffer size: (%d) bytes of captured content",
content_length, buffer.size());
return content_length;
} // end case CONTENT
} // end switch
}
}
return 0;
} // end RemoteCameraHttp::GetResponse
int RemoteCameraHttp::PrimeCapture() {
if ( sd < 0 ) {
Connect();
if ( sd < 0 ) {
return -1;
}
mode = SINGLE_IMAGE;
buffer.clear();
}
getVideoStream();
return 1;
}
int RemoteCameraHttp::PreCapture() {
if ( sd < 0 ) {
Connect();
if ( sd < 0 ) {
return -1;
}
mode = SINGLE_IMAGE;
buffer.clear();
}
if ( mode == SINGLE_IMAGE ) {
if ( SendRequest() < 0 ) {
Error("Unable to send request");
return -1;
}
}
return 1;
} // end int RemoteCameraHttp::PreCapture()
int RemoteCameraHttp::Capture(std::shared_ptr<ZMPacket> &packet) {
int content_length = GetResponse();
if (content_length == 0) {
Warning("Unable to capture image, retrying");
return 0;
}
if (content_length < 0) {
Error("Unable to get response, disconnecting");
return -1;
}
if (!packet->image) {
Debug(4, "Allocating image");
packet->image = new Image(width, height, colours, subpixelorder);
}
Image *image = packet->image;
packet->keyframe = 1;
packet->codec_type = AVMEDIA_TYPE_VIDEO;
packet->packet->stream_index = mVideoStreamId;
packet->stream = mVideoStream;
switch (format) {
case JPEG :
if (!image->DecodeJpeg(buffer.extract(content_length), content_length, colours, subpixelorder)) {
Error("Unable to decode jpeg");
return -1;
}
break;
case X_RGB :
if (content_length != (long)image->Size()) {
Error("Image length mismatch, expected %d bytes, content length was %d",
image->Size(), content_length);
return -1;
}
image->Assign(width, height, colours, subpixelorder, buffer.head(), imagesize);
break;
case X_RGBZ :
if (!image->Unzip(buffer.extract(content_length), content_length)) {
Error("Unable to unzip RGB image");
return -1;
}
image->Assign(width, height, colours, subpixelorder, buffer.head(), imagesize);
break;
default :
Error("Unexpected image format encountered");
return -1;
}
return 1;
} // end ZmPacket *RmoteCameraHttp::Capture( &image );
int RemoteCameraHttp::PostCapture() {
return 1;
}