int CWebserverRequest::OpenFile(std::string path, std::string filename)
{
struct stat statbuf;
int fd= -1;
tmpstring = GetFileName(path, filename);
if(tmpstring.length() > 0)
{
fd = open( tmpstring.c_str(), O_RDONLY );
if (fd<=0)
{
aprintf("cannot open file %s: ", filename.c_str());
dperror("");
}
fstat(fd,&statbuf);
if (!S_ISREG(statbuf.st_mode)) {
close(fd);
fd = -1;
}
}
return fd;
}
void editorUpdatePreview(uint32_t framenum)
{
//
//
//
uint32_t fl,len;
ADM_assert(preview);
ADM_assert(unpackd);
if( GUI_StillAlive())
{
aprintf("Preview: Ask for frame %lu\n",framenum);
if(framenum<=preview->getInfo()->nb_frames-1)
{
preview->getFrameNumberNoAlloc(framenum,&len,unpackd,&fl);
GUI_PreviewUpdate(unpackd->data);
}
}
// virtual uint8_t getFrameNumberNoAlloc(uint32_t frame, uint32_t *len,
// uint8_t *data,uint32_t *flags)=0;
}
/* get_netscape_format()
*
* Formats a string for Netscape output file, w/o a newline at the end.
*
* Function returns a char * to a formatted line. Has to be free()d
*/
static char *get_netscape_format(const struct Cookie *co)
{
return aprintf(
"%s" /* httponly preamble */
"%s%s\t" /* domain */
"%s\t" /* tailmatch */
"%s\t" /* path */
"%s\t" /* secure */
"%" FORMAT_OFF_T "\t" /* expires */
"%s\t" /* name */
"%s", /* value */
co->httponly?"#HttpOnly_":"",
/* Make sure all domains are prefixed with a dot if they allow
tailmatching. This is Mozilla-style. */
(co->tailmatch && co->domain && co->domain[0] != '.')? ".":"",
co->domain?co->domain:"unknown",
co->tailmatch?"TRUE":"FALSE",
co->path?co->path:"/",
co->secure?"TRUE":"FALSE",
co->expires,
co->name,
co->value?co->value:"");
}
//=============================================================================
// SocketList Handler
//=============================================================================
//-----------------------------------------------------------------------------
// Accept new Connection
//-----------------------------------------------------------------------------
int CWebserver::AcceptNewConnectionSocket()
{
int slot = -1;
CySocket *connectionSock = NULL;
int newfd;
if(!(connectionSock = listenSocket.accept() )) // Blocking wait
{
dperror("Socket accept error. Continue.\n");
delete connectionSock;
return -1;
}
#ifdef Y_CONFIG_USE_OPEN_SSL
if(Cyhttpd::ConfigList["SSL"]=="true")
connectionSock->initAsSSL(); // make it a SSL-socket
#endif
log_level_printf(2,"FD: new con fd:%d on port:%d\n",connectionSock->get_socket(), connectionSock->get_accept_port());
// Add Socket to List
slot = SL_GetFreeSlot();
if(slot < 0)
{
connectionSock->close();
aprintf("No free Slot in SocketList found. Open:%d\n",open_connections);
}
else
{
SocketList[slot] = connectionSock; // put it to list
fcntl(connectionSock->get_socket() , F_SETFD , O_NONBLOCK); // set non-blocking
open_connections++; // count open connectins
newfd = connectionSock->get_socket();
if (newfd > fdmax) // keep track of the maximum fd
fdmax = newfd;
}
return slot;
}
uint8_t avsHeader::askFor(uint32_t cmd,uint32_t frame, uint32_t payloadsize,uint8_t *payload)
{
if(!sendData(cmd,frame,0,NULL))
{
printf("[avsProxy]Send Cmd %u failed for frame %u\n",cmd,frame);
return 0;
}
// Wait reply
uint32_t size,reply,outframe;
if(!receiveData(&reply,&outframe,&size,payload))
{
printf("[avsProxy]Rx Cmd %u failed for frame %u\n",cmd,frame);
return 0;
}
// Check!
ADM_assert(outframe==frame);
ADM_assert(reply==cmd+1);
ADM_assert(size==payloadsize);
aprintf("[avsProxy]Cmd %u on frame %u succeed\n",cmd,frame);
return 1;
}
/*
Go to Frame num, from segment seg
Used to compute the duration of audio track
*/
uint8_t ADM_Composer::audioGoToFn (uint32_t seg, uint32_t fn, uint32_t * noff)
{
uint32_t time;
aprintf("Editor: audioGoToFn go to : seg %lu fn %lu \n",seg,fn);
// since we got the frame we can find the segment
if (seg >= _nb_segment)
{
printf("[audioGotoFn] asked : %d max :%d\n",seg,_nb_segment);
ADM_assert(seg<_nb_segment);
}
ADM_assert (_videos[SEG]._audiostream);
_audioseg=seg;
#undef AS
#define AS _videos[SEG]._audiostream
time = _videos[SEG]._aviheader->getTime (fn);
AS->goToTime (time);
*noff = AS->getPos ();
return AS->goToTime (time);
}
uint8_t ADM_vorbis::run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut)
{
ogg_packet packet;
float **sample_pcm;
int nb_synth;
*nbOut=0;
if(!_init) return 0;
packet.b_o_s=0;
packet.e_o_s=0;
packet.bytes=nbIn;
packet.packet=inptr;
packet.granulepos=-1;
if(!vorbis_synthesis(&STRUCT->vblock,&packet))
{
vorbis_synthesis_blockin(&STRUCT->vdsp,&STRUCT->vblock);
}
nb_synth=vorbis_synthesis_pcmout(&STRUCT->vdsp,&sample_pcm);
if(nb_synth<0)
{
printf("error decoding vorbis %d\n",nb_synth);
return 0;
}
for (uint32_t samp = 0; samp < nb_synth; samp++)
for (uint8_t chan = 0; chan < STRUCT->vinfo.channels; chan++)
*outptr++ = sample_pcm[chan][samp] * STRUCT->ampscale;
*nbOut = STRUCT->vinfo.channels * nb_synth;
// Puge them
vorbis_synthesis_read(&STRUCT->vdsp,nb_synth);
aprintf("This round : in %d bytes, out %d bytes synthetized:%d\n",nbIn,*nbOut,nb_synth);
return 1;
}
static CURLcode nss_load_cert(struct ssl_connect_data *ssl,
const char *filename, PRBool cacert)
{
CURLcode err = (cacert)
? CURLE_SSL_CACERT_BADFILE
: CURLE_SSL_CERTPROBLEM;
/* libnsspem.so leaks memory if the requested file does not exist. For more
* details, go to <https://bugzilla.redhat.com/734760>. */
if(is_file(filename))
err = nss_create_object(ssl, CKO_CERTIFICATE, filename, cacert);
if(CURLE_OK == err && !cacert) {
/* we have successfully loaded a client certificate */
CERTCertificate *cert;
char *nickname = NULL;
char *n = strrchr(filename, '/');
if(n)
n++;
/* The following undocumented magic helps to avoid a SIGSEGV on call
* of PK11_ReadRawAttribute() from SelectClientCert() when using an
* immature version of libnsspem.so. For more details, go to
* <https://bugzilla.redhat.com/733685>. */
nickname = aprintf("PEM Token #1:%s", n);
if(nickname) {
cert = PK11_FindCertFromNickname(nickname, NULL);
if(cert)
CERT_DestroyCertificate(cert);
free(nickname);
}
}
return err;
}
uint8_t ADMVideoMPD3Dlow::setup(void)
{
double LumSpac, LumTmp, ChromSpac, ChromTmp;
LumSpac = _param->param1;
LumTmp = _param->param3;
ChromSpac = _param->param2;
ChromTmp = LumTmp * ChromSpac / LumSpac;
PrecalcCoefs((int *)Coefs[0], LumSpac);
PrecalcCoefs((int *)Coefs[1], LumTmp);
PrecalcCoefs((int *)Coefs[2], ChromSpac);
PrecalcCoefs((int *)Coefs[3], ChromTmp);
aprintf("\n Param : %lf %lf %lf \n",
_param->param1,
_param->param2,
_param->param3);
_last=0xFFFFFFF;
return 1;
}
static char *format_request(char *host, char *port, char *path, char **headers) {
char *req = NULL;
uint8_t has_host = 0;
aprintf(&req, "GET %s HTTP/1.1\r\n", path);
for (char **h = headers; *h != NULL; h++) {
if (strncasecmp(*h, "Host:", strlen("Host:")) == 0)
has_host = 1;
aprintf(&req, "%s\r\n", *h);
}
if (!has_host) {
aprintf(&req, "Host: %s", host);
if (port) aprintf(&req, ":%s", port);
aprintf(&req, "\r\n");
}
aprintf(&req, "\r\n");
return req;
}
bool face_points(cv::Mat* img,float* landmarks, bool add_boundary_points = true) {
const char* path = "/data/data/org.stasmdemo.android/app_stasm/testface.jpg";
// cv::Mat img=cv::imread(imgpath,CV_LOAD_IMAGE_GRAYSCALE);//注意！！这里需要完成img转换
if(!img->data){
aprintf("-------stasm ------------- img load fail");
return false;
}
int foundface;
aprintf("locator face_points landmarks : %i ptr : %i",len(landmarks),landmarks);
if(!stasm_search_single(&foundface,landmarks,(const char*)img->data,img->cols,img->rows,path,"/data/data/org.stasmdemo.android/app_stasm/")){
aprintf("--------stasm------------error in stasm search single");
return false;
}
aprintf("locator face_points landmarks : %i ptr : %i",len(landmarks),landmarks);
if(!foundface){
aprintf("-------stasm-------------no face found");
}else{
stasm_force_points_into_image(landmarks,img->cols,img->rows);
}
aprintf("locator face_points landmarks : %i ptr : %i",len(landmarks),landmarks);
return true;
}
/* returns an allocated key to find a bundle for this connection */
static char *hashkey(struct connectdata *conn)
{
return aprintf("%s:%d",
conn->bits.proxy?conn->proxy.name:conn->host.name,
conn->localport);
}
CURLcode Curl_output_digest(struct connectdata *conn,
bool proxy,
const unsigned char *request,
const unsigned char *uripath)
{
/* We have a Digest setup for this, use it! Now, to get all the details for
this sorted out, I must urge you dear friend to read up on the RFC2617
section 3.2.2, */
size_t urilen;
unsigned char md5buf[16]; /* 16 bytes/128 bits */
unsigned char request_digest[33];
unsigned char *md5this;
unsigned char ha1[33];/* 32 digits and 1 zero byte */
unsigned char ha2[33];/* 32 digits and 1 zero byte */
char cnoncebuf[33];
char *cnonce = NULL;
size_t cnonce_sz = 0;
char *tmp = NULL;
char **allocuserpwd;
size_t userlen;
const char *userp;
char *userp_quoted;
const char *passwdp;
struct auth *authp;
struct SessionHandle *data = conn->data;
struct digestdata *d;
CURLcode result;
/* The CURL_OUTPUT_DIGEST_CONV macro below is for non-ASCII machines.
It converts digest text to ASCII so the MD5 will be correct for
what ultimately goes over the network.
*/
#define CURL_OUTPUT_DIGEST_CONV(a, b) \
result = Curl_convert_to_network(a, (char *)b, strlen((const char*)b)); \
if(result) { \
free(b); \
return result; \
}
if(proxy) {
d = &data->state.proxydigest;
allocuserpwd = &conn->allocptr.proxyuserpwd;
userp = conn->proxyuser;
passwdp = conn->proxypasswd;
authp = &data->state.authproxy;
}
else {
d = &data->state.digest;
allocuserpwd = &conn->allocptr.userpwd;
userp = conn->user;
passwdp = conn->passwd;
authp = &data->state.authhost;
}
Curl_safefree(*allocuserpwd);
/* not set means empty */
if(!userp)
userp="";
if(!passwdp)
passwdp="";
if(!d->nonce) {
authp->done = FALSE;
return CURLE_OK;
}
authp->done = TRUE;
if(!d->nc)
d->nc = 1;
if(!d->cnonce) {
snprintf(cnoncebuf, sizeof(cnoncebuf), "%08x%08x%08x%08x",
Curl_rand(data), Curl_rand(data),
Curl_rand(data), Curl_rand(data));
result = Curl_base64_encode(data, cnoncebuf, strlen(cnoncebuf),
&cnonce, &cnonce_sz);
if(result)
return result;
d->cnonce = cnonce;
}
/*
if the algorithm is "MD5" or unspecified (which then defaults to MD5):
A1 = unq(username-value) ":" unq(realm-value) ":" passwd
if the algorithm is "MD5-sess" then:
A1 = H( unq(username-value) ":" unq(realm-value) ":" passwd )
":" unq(nonce-value) ":" unq(cnonce-value)
*/
md5this = (unsigned char *)
aprintf("%s:%s:%s", userp, d->realm, passwdp);
if(!md5this)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
Curl_md5it(md5buf, md5this);
Curl_safefree(md5this);
md5_to_ascii(md5buf, ha1);
if(d->algo == CURLDIGESTALGO_MD5SESS) {
/* nonce and cnonce are OUTSIDE the hash */
tmp = aprintf("%s:%s:%s", ha1, d->nonce, d->cnonce);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, tmp); /* convert on non-ASCII machines */
Curl_md5it(md5buf, (unsigned char *)tmp);
Curl_safefree(tmp);
md5_to_ascii(md5buf, ha1);
}
/*
If the "qop" directive's value is "auth" or is unspecified, then A2 is:
A2 = Method ":" digest-uri-value
If the "qop" value is "auth-int", then A2 is:
A2 = Method ":" digest-uri-value ":" H(entity-body)
(The "Method" value is the HTTP request method as specified in section
5.1.1 of RFC 2616)
*/
/* So IE browsers < v7 cut off the URI part at the query part when they
evaluate the MD5 and some (IIS?) servers work with them so we may need to
do the Digest IE-style. Note that the different ways cause different MD5
sums to get sent.
Apache servers can be set to do the Digest IE-style automatically using
the BrowserMatch feature:
http://httpd.apache.org/docs/2.2/mod/mod_auth_digest.html#msie
Further details on Digest implementation differences:
http://www.fngtps.com/2006/09/http-authentication
*/
if(authp->iestyle && ((tmp = strchr((char *)uripath, '?')) != NULL))
urilen = tmp - (char *)uripath;
else
urilen = strlen((char *)uripath);
md5this = (unsigned char *)aprintf("%s:%.*s", request, urilen, uripath);
if(d->qop && Curl_raw_equal(d->qop, "auth-int")) {
/* We don't support auth-int for PUT or POST at the moment.
TODO: replace md5 of empty string with entity-body for PUT/POST */
unsigned char *md5this2 = (unsigned char *)
aprintf("%s:%s", md5this, "d41d8cd98f00b204e9800998ecf8427e");
Curl_safefree(md5this);
md5this = md5this2;
}
if(!md5this)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
Curl_md5it(md5buf, md5this);
Curl_safefree(md5this);
md5_to_ascii(md5buf, ha2);
if(d->qop) {
md5this = (unsigned char *)aprintf("%s:%s:%08x:%s:%s:%s",
ha1,
d->nonce,
d->nc,
d->cnonce,
d->qop,
ha2);
}
else {
md5this = (unsigned char *)aprintf("%s:%s:%s",
ha1,
d->nonce,
ha2);
}
if(!md5this)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
Curl_md5it(md5buf, md5this);
Curl_safefree(md5this);
md5_to_ascii(md5buf, request_digest);
/* for test case 64 (snooped from a Mozilla 1.3a request)
Authorization: Digest username="******", realm="testrealm", \
nonce="1053604145", uri="/64", response="c55f7f30d83d774a3d2dcacf725abaca"
Digest parameters are all quoted strings. Username which is provided by
the user will need double quotes and backslashes within it escaped. For
the other fields, this shouldn't be an issue. realm, nonce, and opaque
are copied as is from the server, escapes and all. cnonce is generated
with web-safe characters. uri is already percent encoded. nc is 8 hex
characters. algorithm and qop with standard values only contain web-safe
chracters.
*/
userp_quoted = string_quoted(userp);
if(!userp_quoted)
return CURLE_OUT_OF_MEMORY;
if(d->qop) {
*allocuserpwd =
aprintf( "%sAuthorization: Digest "
"username=\"%s\", "
"realm=\"%s\", "
"nonce=\"%s\", "
"uri=\"%.*s\", "
"cnonce=\"%s\", "
"nc=%08x, "
"qop=%s, "
"response=\"%s\"",
proxy?"Proxy-":"",
userp_quoted,
d->realm,
d->nonce,
urilen, uripath, /* this is the PATH part of the URL */
d->cnonce,
d->nc,
d->qop,
request_digest);
if(Curl_raw_equal(d->qop, "auth"))
d->nc++; /* The nc (from RFC) has to be a 8 hex digit number 0 padded
which tells to the server how many times you are using the
same nonce in the qop=auth mode. */
}
else {
*allocuserpwd =
aprintf( "%sAuthorization: Digest "
"username=\"%s\", "
"realm=\"%s\", "
"nonce=\"%s\", "
"uri=\"%.*s\", "
"response=\"%s\"",
proxy?"Proxy-":"",
userp_quoted,
d->realm,
d->nonce,
urilen, uripath, /* this is the PATH part of the URL */
request_digest);
}
Curl_safefree(userp_quoted);
if(!*allocuserpwd)
return CURLE_OUT_OF_MEMORY;
/* Add optional fields */
if(d->opaque) {
/* append opaque */
tmp = aprintf("%s, opaque=\"%s\"", *allocuserpwd, d->opaque);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
free(*allocuserpwd);
*allocuserpwd = tmp;
}
if(d->algorithm) {
/* append algorithm */
tmp = aprintf("%s, algorithm=\"%s\"", *allocuserpwd, d->algorithm);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
free(*allocuserpwd);
*allocuserpwd = tmp;
}
/* append CRLF + zero (3 bytes) to the userpwd header */
userlen = strlen(*allocuserpwd);
tmp = realloc(*allocuserpwd, userlen + 3);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
strcpy(&tmp[userlen], "\r\n"); /* append the data */
*allocuserpwd = tmp;
return CURLE_OK;
}
CURLcode Curl_output_digest(struct connectdata *conn,
bool proxy,
const unsigned char *request,
const unsigned char *uripath)
{
/* We have a Digest setup for this, use it! Now, to get all the details for
this sorted out, I must urge you dear friend to read up on the RFC2617
section 3.2.2, */
unsigned char md5buf[16]; /* 16 bytes/128 bits */
unsigned char request_digest[33];
unsigned char *md5this;
unsigned char *ha1;
unsigned char ha2[33];/* 32 digits and 1 zero byte */
char cnoncebuf[7];
char *cnonce;
char *tmp = NULL;
struct timeval now;
char **allocuserpwd;
const char *userp;
const char *passwdp;
struct auth *authp;
struct SessionHandle *data = conn->data;
struct digestdata *d;
#ifdef CURL_DOES_CONVERSIONS
CURLcode rc;
/* The CURL_OUTPUT_DIGEST_CONV macro below is for non-ASCII machines.
It converts digest text to ASCII so the MD5 will be correct for
what ultimately goes over the network.
*/
#define CURL_OUTPUT_DIGEST_CONV(a, b) \
rc = Curl_convert_to_network(a, (char *)b, strlen((const char*)b)); \
if(rc != CURLE_OK) { \
free(b); \
return rc; \
}
#else
#define CURL_OUTPUT_DIGEST_CONV(a, b)
#endif /* CURL_DOES_CONVERSIONS */
if(proxy) {
d = &data->state.proxydigest;
allocuserpwd = &conn->allocptr.proxyuserpwd;
userp = conn->proxyuser;
passwdp = conn->proxypasswd;
authp = &data->state.authproxy;
}
else {
d = &data->state.digest;
allocuserpwd = &conn->allocptr.userpwd;
userp = conn->user;
passwdp = conn->passwd;
authp = &data->state.authhost;
}
if(*allocuserpwd) {
Curl_safefree(*allocuserpwd);
*allocuserpwd = NULL;
}
/* not set means empty */
if(!userp)
userp="";
if(!passwdp)
passwdp="";
if(!d->nonce) {
authp->done = FALSE;
return CURLE_OK;
}
authp->done = TRUE;
if(!d->nc)
d->nc = 1;
if(!d->cnonce) {
/* Generate a cnonce */
now = Curl_tvnow();
snprintf(cnoncebuf, sizeof(cnoncebuf), "%06ld", (long)now.tv_sec);
if(Curl_base64_encode(data, cnoncebuf, strlen(cnoncebuf), &cnonce))
d->cnonce = cnonce;
else
return CURLE_OUT_OF_MEMORY;
}
/*
if the algorithm is "MD5" or unspecified (which then defaults to MD5):
A1 = unq(username-value) ":" unq(realm-value) ":" passwd
if the algorithm is "MD5-sess" then:
A1 = H( unq(username-value) ":" unq(realm-value) ":" passwd )
":" unq(nonce-value) ":" unq(cnonce-value)
*/
md5this = (unsigned char *)
aprintf("%s:%s:%s", userp, d->realm, passwdp);
if(!md5this)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
Curl_md5it(md5buf, md5this);
free(md5this); /* free this again */
ha1 = malloc(33); /* 32 digits and 1 zero byte */
if(!ha1)
return CURLE_OUT_OF_MEMORY;
md5_to_ascii(md5buf, ha1);
if(d->algo == CURLDIGESTALGO_MD5SESS) {
/* nonce and cnonce are OUTSIDE the hash */
tmp = aprintf("%s:%s:%s", ha1, d->nonce, d->cnonce);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, tmp); /* convert on non-ASCII machines */
Curl_md5it(md5buf, (unsigned char *)tmp);
free(tmp); /* free this again */
md5_to_ascii(md5buf, ha1);
}
/*
If the "qop" directive's value is "auth" or is unspecified, then A2 is:
A2 = Method ":" digest-uri-value
If the "qop" value is "auth-int", then A2 is:
A2 = Method ":" digest-uri-value ":" H(entity-body)
(The "Method" value is the HTTP request method as specified in section
5.1.1 of RFC 2616)
*/
/* So IE browsers < v7 cut off the URI part at the query part when they
evaluate the MD5 and some (IIS?) servers work with them so we may need to
do the Digest IE-style. Note that the different ways cause different MD5
sums to get sent.
Apache servers can be set to do the Digest IE-style automatically using
the BrowserMatch feature:
http://httpd.apache.org/docs/2.2/mod/mod_auth_digest.html#msie
Further details on Digest implementation differences:
http://www.fngtps.com/2006/09/http-authentication
*/
if(authp->iestyle && ((tmp = strchr((char *)uripath, '?')) != NULL)) {
md5this = (unsigned char *)aprintf("%s:%.*s", request,
(int)(tmp - (char *)uripath), uripath);
}
else
md5this = (unsigned char *)aprintf("%s:%s", request, uripath);
if(!md5this) {
free(ha1);
return CURLE_OUT_OF_MEMORY;
}
if(d->qop && Curl_raw_equal(d->qop, "auth-int")) {
/* We don't support auth-int at the moment. I can't see a easy way to get
entity-body here */
/* TODO: Append H(entity-body)*/
}
CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
Curl_md5it(md5buf, md5this);
free(md5this); /* free this again */
md5_to_ascii(md5buf, ha2);
if(d->qop) {
md5this = (unsigned char *)aprintf("%s:%s:%08x:%s:%s:%s",
ha1,
d->nonce,
d->nc,
d->cnonce,
d->qop,
ha2);
}
else {
md5this = (unsigned char *)aprintf("%s:%s:%s",
ha1,
d->nonce,
ha2);
}
free(ha1);
if(!md5this)
return CURLE_OUT_OF_MEMORY;
CURL_OUTPUT_DIGEST_CONV(data, md5this); /* convert on non-ASCII machines */
Curl_md5it(md5buf, md5this);
free(md5this); /* free this again */
md5_to_ascii(md5buf, request_digest);
/* for test case 64 (snooped from a Mozilla 1.3a request)
Authorization: Digest username="******", realm="testrealm", \
nonce="1053604145", uri="/64", response="c55f7f30d83d774a3d2dcacf725abaca"
*/
if(d->qop) {
*allocuserpwd =
aprintf( "%sAuthorization: Digest "
"username=\"%s\", "
"realm=\"%s\", "
"nonce=\"%s\", "
"uri=\"%s\", "
"cnonce=\"%s\", "
"nc=%08x, "
"qop=\"%s\", "
"response=\"%s\"",
proxy?"Proxy-":"",
userp,
d->realm,
d->nonce,
uripath, /* this is the PATH part of the URL */
d->cnonce,
d->nc,
d->qop,
request_digest);
if(Curl_raw_equal(d->qop, "auth"))
d->nc++; /* The nc (from RFC) has to be a 8 hex digit number 0 padded
which tells to the server how many times you are using the
same nonce in the qop=auth mode. */
}
else {
*allocuserpwd =
aprintf( "%sAuthorization: Digest "
"username=\"%s\", "
"realm=\"%s\", "
"nonce=\"%s\", "
"uri=\"%s\", "
"response=\"%s\"",
proxy?"Proxy-":"",
userp,
d->realm,
d->nonce,
uripath, /* this is the PATH part of the URL */
request_digest);
}
if(!*allocuserpwd)
return CURLE_OUT_OF_MEMORY;
/* Add optional fields */
if(d->opaque) {
/* append opaque */
tmp = aprintf("%s, opaque=\"%s\"", *allocuserpwd, d->opaque);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
free(*allocuserpwd);
*allocuserpwd = tmp;
}
if(d->algorithm) {
/* append algorithm */
tmp = aprintf("%s, algorithm=\"%s\"", *allocuserpwd, d->algorithm);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
free(*allocuserpwd);
*allocuserpwd = tmp;
}
/* append CRLF + zero (3 bytes) to the userpwd header */
tmp = realloc(*allocuserpwd, strlen(*allocuserpwd) + 3);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
strcat(tmp, "\r\n");
*allocuserpwd = tmp;
return CURLE_OK;
}
/*
Called when the hscale is changed
*/
void drag(GtkButton * button, gpointer user_data)
{
UNUSED_ARG(button);
UNUSED_ARG(user_data);
double percent;
float x,y;
float sr_mul,dst_mul;
int32_t xx,yy;
percent = GTK_ADJUSTMENT(adj_angle)->value;
if(percent<10.0) percent=10.;
read();
aprintf("drag called : %f \n",percent);
x=ow;
y=oh;
erx=0;
ery=0;
sr_mul=1.;
if(sar)
{ // source is 4/3 or 16/9
sr_mul=aspectRatio[pal][sar];
}
dst_mul=1.;
if(dar)
{ // dst is 4/3 or 16/9
dst_mul=1/aspectRatio[pal][dar];
}
aprintf("source mul %02.2f , dst mul : %02.2f\n",sr_mul,dst_mul);
x=x*sr_mul*dst_mul;
y=y;
// normalize it to recover 100% width
y=y/(x/ow);
x=ow;
aprintf("AR:x,y : %03f %03f \n",x,y);
percent/=100.;
x=x*percent;
y=y*percent;
aprintf("AR x,y : %03f %03f \n",x,y);
xx=(uint32_t)floor(x+0.5);
yy=(uint32_t)floor(y+0.5);
if(xx&1) xx--;
if(yy&1) yy--;
if(roundBool)
{
int32_t ox=xx,oy=yy;
xx=(xx +7) & 0xfffff0;
yy=(yy +7) & 0xfffff0;
erx=(xx-ox);
erx=erx/xx;
ery=(yy-oy);
ery=ery/yy;
aprintf("x: %d -> %d : err %f\n",ox,xx,erx);
aprintf("y: %d -> %d : err %f\n",oy,yy,ery);
}
iw=xx;
ih=yy;
write();
}
//___________________________________________________________________________
uint8_t lavMuxer::writeVideoPacket(ADMBitstream *bitstream)
{
int ret;
double p,d;
AVPacket pkt;
av_init_packet(&pkt);
p=bitstream->ptsFrame+1; // Pts // Time p/fps1000=out/den out=p*den*1000/fps1000
p=(p*1000*1000*1000);
p=p/_fps1000; // in us
d=bitstream->dtsFrame; // dts
d=(d*1000*1000*1000);
d=d/_fps1000;
_curDTS=(int64_t)floor(d);
// Rescale
#define RESCALE(x) x=x*video_st->codec->time_base.den*1000.;\
x=x/_fps1000;
p=bitstream->ptsFrame+1;
RESCALE(p);
d=bitstream->dtsFrame;
RESCALE(d);
pkt.dts=(int64_t)floor(d);
pkt.pts=(int64_t)floor(p);
// printf("Lavformat : Pts :%u dts:%u",displayframe,frameno);
aprintf("Lavformat : Pts :%llu dts:%llu",pkt.pts,pkt.dts);
pkt.stream_index=0;
pkt.data= bitstream->data;
pkt.size= bitstream->len;
// Look if it is a gop start or seq start
if(_type==MUXER_MP4)
{
if(bitstream->flags & AVI_KEY_FRAME)
pkt.flags |= PKT_FLAG_KEY;
}else
if(!bitstream->data[0] && !bitstream->data[1] && bitstream->data[2]==1)
{
if(bitstream->data[3]==0xb3 || bitstream->data[3]==0xb8 ) // Seq start or gop start
pkt.flags |= PKT_FLAG_KEY;
//printf("Intra\n");
}
ret =av_write_frame(oc, &pkt);
if(ret)
{
printf("Error writing video packet\n");
return 0;
}
aprintf("V: frame %lu pts%d\n",bitstream->dtsFrame,pkt.pts);
return 1;
}
//________________________________________________
uint8_t ADM_ogmWriteProcess::initVideo(char *name)
{
uint32_t w,h,fps1000,fcc;
_incoming = getLastVideoFilter (frameStart,frameEnd-frameStart);
_togo=_incoming->getInfo()->nb_frames;
_encode = getVideoEncoder (_incoming->getInfo()->width,_incoming->getInfo()->height);
if (!_encode)
return 0;
TwoPassLogFile=new char[strlen(name)+6];
strcpy(TwoPassLogFile,name);
strcat(TwoPassLogFile,".stat");
_encode->setLogFile(TwoPassLogFile,_togo);
if (!_encode->configure (_incoming))
{
delete _encode;
_encode = NULL;
GUI_Alert ("Init of filter failed");
return 0;
};
w= _incoming->getInfo ()->width;
h=_incoming->getInfo ()->height;
fps1000=_incoming->getInfo ()->fps1000;
_fps1000=fps1000;
fcc= fourCC::get((uint8_t *)_encode->getCodecName());
_videoBuffer=new uint8_t[w*h*3];
encoding_gui->setCodec(_encode->getDisplayName());
//-----------------------VBR--------------------------------------
if (_encode->isDualPass ())
{
uint8_t *buffer;
uint32_t len, flag;
FILE *tmp;
uint8_t reuse=0;
aprintf("\n** Dual pass encoding**\n");
if((tmp=fopen(TwoPassLogFile,"rt")))
{
fclose(tmp);
if(GUI_Question("\n Reuse the existing log-file ?"))
{
reuse=1;
}
}
if(!reuse)
{
aprintf("**Pass 1:%lu\n",_togo);
_encode->startPass1 ();
encoding_gui->setCodec((char *)_encode->getCodecName());
encoding_gui->setPhasis("Pass one");
//__________________________________
// now go to main loop.....
//__________________________________
for (uint32_t cf = 0; cf < _togo; cf++)
{
if (!_encode->encode (cf, &len, _videoBuffer, &flag))
{
printf("\n Encoding of frame %lu failed !\n",cf);
return 0;
}
encoding_gui->feedFrame(len);
encoding_gui->setFrame(cf,_togo);
encoding_gui->setQuant(_encode->getLastQz());
if(!encoding_gui->isAlive())
{
return 0;
}
}
aprintf("**Pass 1:done\n");
}// End of reuse
if(!_encode->startPass2 ())
{
printf("Pass2 ignition failed\n");
return 0;
}
encoding_gui->setPhasis("Pass 2");
} //-------------------------/VBR-----------------------------------
else
{
encoding_gui->setPhasis("Encoding");
}
// init save avi
// now we build the new stream !
aprintf("**main pass:\n");
stream_header header;
int64_t dur64;
uint32_t dur32;
uint16_t dur16;
memset(&header,0,sizeof(header));
memcpy(&(header.streamtype),"video\0\0\0",8);
MEMCPY(&(header.subtype),&fcc,4);
//header.size=sizeof(header);
dur32=sizeof(header);
MEMCPY(&header.size,&dur32,4);
MEMCPY(&(header.video.width),&w,4);
MEMCPY(&(header.video.height),&h,4);
// Timing ..
double duration; // duration in 10us
duration=fps1000;
duration=1000./duration;
duration*=1000*1000;
duration*=10;
dur64=(int64_t)duration;
MEMCPY(&header.time_unit,&dur64,8);
dur64=1;
MEMCPY(&header.samples_per_unit,&dur64,8);
dur32=0x10000;
MEMCPY(&header.buffersize,&dur32,4);
dur16=24;
MEMCPY(&header.bits_per_sample,&dur16,2);
//header.default_len=1;
dur32=1;
MEMCPY(&header.default_len,&dur32,4);
return videoStream->writeHeaders(sizeof(header),(uint8_t *)&header); // +4 ?
}
//______________________________________
//
// Open and get the headears/index built
// along way
//______________________________________
uint8_t OpenDMLHeader::open(const char *name)
{
uint8_t badAvi=0;
uint32_t rd;
printf("** opening OpenDML files **");
_fd=fopen(name,"rb");
if(!_fd)
{
printf("\n cannot open %s \n",name);
return 0;
}
myName=ADM_strdup(name);
#define CLR(x) memset(& x,0,sizeof( x));
CLR( _videostream);
CLR( _mainaviheader);
_isvideopresent=1;
_isaudiopresent=0;
_nbTrack=0;
riffParser *parser=new riffParser(name);
if(MKFCC('R','I','F','F')!=(rd=parser->read32()))
{
printf("Not riff\n");badAvi=1;
printf("%lx != %lx\n",rd,MKFCC('R','I','F','F'));
}
parser->read32();
if(MKFCC('A','V','I',' ')!=parser->read32())
{
printf("Not Avi\n");badAvi=1;
}
if(!badAvi)
{
walk(parser);
}
delete parser;
aprintf("Found %d tracks\n:-----------\n",_nbTrack);
// check if it looks like a correct avi
if(!_nbTrack) badAvi=1;
// if we are up to here -> good avi :)
if(badAvi)
{
printf("FAIL\n");
return 0;
}
// now read up each parts...
//____________________________
#ifdef __WIN32
#define DUMP_TRACK(i) aprintf(" at %I64u (%I64x) size : %I64u (%I64x)\n", \
_Tracks[i].strh.offset,\
_Tracks[i].strh.offset,\
_Tracks[i].strh.size,\
_Tracks[i].strh.size);
#else
#define DUMP_TRACK(i) aprintf(" at %llu (%llx) size : %llu (%llx)\n", \
_Tracks[i].strh.offset,\
_Tracks[i].strh.offset,\
_Tracks[i].strh.size,\
_Tracks[i].strh.size);
#endif
for(uint32_t i=0;i<_nbTrack;i++)
{
DUMP_TRACK(i);
}
uint32_t vidTrack=0xff;
// search wich track is the video one
// and load it to _videoheader
for(uint32_t i=0;i<_nbTrack;i++)
{
fseeko(_fd,_Tracks[i].strh.offset,SEEK_SET);
if(_Tracks[i].strh.size!=sizeof(_videostream))
{
printf("Mmm(1) we have a bogey here, size mismatch : %"LLU"\n",_Tracks[i].strh.size);
printf("expected %d\n",sizeof(_videostream));
if(_Tracks[i].strh.size<sizeof(_videostream)-8) // RECT is not mandatory
{
GUI_Error_HIG(QT_TR_NOOP("Malformed header"), NULL);
return 0;
}
printf("Trying to continue anyway\n");
}
fread(&_videostream,sizeof(_videostream),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_AviStreamHeader(&_videostream);
#endif
if(_videostream.fccType==MKFCC('v','i','d','s'))
{
vidTrack=i;
printf("Video track is %ld\n",i);
break;
}
}
if(0xff==vidTrack)
{
printf("Could not identify video track!");
return 0;
}
// STOP HERE -> Alex <-
//return 0;
// STOP HERE -> Alex <-
// then bih stuff
int32_t extra;
// _fd=fopen(name,"rb");
fseeko(_fd,_Tracks[vidTrack].strf.offset,SEEK_SET);
extra=_Tracks[vidTrack].strf.size-sizeof(_video_bih);
if(extra<0)
{
printf("bih is not big enough (%lu/%lu)!\n",_Tracks[vidTrack].strf.size,sizeof(_video_bih));
return 0;
}
fread(&_video_bih,sizeof(_video_bih),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_BitMapInfo(&_video_bih);
#endif
if(extra>0)
{
_videoExtraLen=extra;
_videoExtraData=new uint8_t [extra];
fread(_videoExtraData,extra,1,_fd);
}
_isvideopresent=1;
//--------------------------------------------------
// Read audio trak info, select if there is
// several
//--------------------------------------------------
// and audio track
if(_mainaviheader.dwStreams>=2)
{
// which one is the audio track, is there several ?
if(!(_nbAudioTracks=countAudioTrack()))
{
printf("Weird, there is no audio track, but more than one stream...\n");
}
else
{
uint32_t run=0,audio=0;
odmlAudioTrack *track;
_audioTracks=new odmlAudioTrack[_nbAudioTracks];
while(audio<_nbAudioTracks)
{
ADM_assert(run<_nbTrack);
track=&(_audioTracks[audio]);
fseeko(_fd,_Tracks[run].strh.offset,SEEK_SET);
if(_Tracks[run].strh.size != sizeof(_audiostream))
{
printf("Mmm(2) we have a bogey here, size mismatch : %"LLU"\n",_Tracks[run].strh.size);
printf("expected %d\n",sizeof(_audiostream));
if(_Tracks[run].strh.size<sizeof(_audiostream)-8)
{
GUI_Error_HIG(QT_TR_NOOP("Malformed header"), NULL);
return 0;
}
printf("Trying to continue anyway\n");
}
fread(track->avistream,sizeof(_audiostream),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_AviStreamHeader(track->avistream);
#endif
if(track->avistream->fccType!=MKFCC('a','u','d','s'))
{
printf("Not an audio track!\n");
run++;
continue;
}
// now read extra stuff
fseeko(_fd,_Tracks[run].strf.offset,SEEK_SET);
extra=_Tracks[run].strf.size-sizeof(WAVHeader);
if(extra<0)
{
printf("WavHeader is not big enough (%lu/%lu)!\n",
_Tracks[run].strf.size,sizeof(WAVHeader));
return 0;
}
fread(track->wavHeader,sizeof(WAVHeader),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_WavHeader(track->wavHeader);
#endif
if(extra>2)
{
fgetc(_fd);fgetc(_fd);
extra-=2;
track->extraDataLen=extra;
track->extraData=new uint8_t [extra];
fread(track->extraData,extra,1,_fd);
}
track->trackNum=run;
audio++;
run++;
}
}
}
// now look at the index stuff
// there could be 3 cases:
// 1- It is a openDML index, meta index + several smaller index
// 2- It is a legacy index (type 1 , most common)
// 3- It is a broken index or no index at all
//
// If it is a openDML index we will find a "indx" field in the Tracks
// Else we will find it in _regularIndex Track
// Since openDML often also have a regular index we will try open DML first
uint8_t ret=0;
Dump();
// take the size of riff header and actual file size
uint64_t riffSize;
fseeko(_fd,0,SEEK_END);
_fileSize=ftello(_fd);
fseeko(_fd,0,SEEK_SET);
read32();
riffSize=(uint64_t )read32();
// 1st case, we have an avi < 4 Gb
// potentially avi type 1
#if 0
if((_fileSize<4*1024*1024*1024LL)&&
// if riff size is ~ fileSize try regular index
(abs(riffSize-_fileSize)<1024*1024))
#endif
#define HAS(x) if(x) printf(#x" : yes\n"); else printf(#x" : no\n");
// If there is no openDML index
HAS( _regularIndex.offset);
HAS( _Tracks[vidTrack].indx.offset);
if(!ret && _regularIndex.offset &&!_Tracks[vidTrack].indx.offset)
// try regular avi if a idx1 field is there (avi index)
ret=indexRegular(vidTrack);
if (!ret && _Tracks[vidTrack].indx.offset) // Try openDML if a index field is there (openDML)
ret=indexODML(vidTrack);
if(!ret)
{
printf("Could not index it properly...\n");
return 0;
}
if(!_nbAudioTracks)
{
_isaudiopresent=0;
}
else
{
// build audio stream
odmlAudioTrack *track;
// Check it is not a weird DV file
if(fourCC::check(_video_bih.biCompression,(uint8_t *)"dvsd"))
{
for(int i=0;i<_nbAudioTracks;i++)
{
track=&(_audioTracks[i]);
WAVHeader *hdr= track->wavHeader;
if(!hdr->frequency)
{
printf("Fixing audio track to be PCM\n");
hdr->frequency=48000;
//hdr->channels=2;
hdr->byterate=48000*hdr->channels*2;
hdr->blockalign=2*hdr->channels;
}
}
}
for(int i=0;i<_nbAudioTracks;i++)
{
track=&(_audioTracks[i]);
_audioTracks[i].track= new AVDMAviAudioStream(track->index,
track->nbChunks,
myName,
track->wavHeader,
0,
track->extraDataLen,track->extraData);
}
}
if (!_video_bih.biCompression && fourCC::check(_videostream.fccHandler,(uint8_t*)"DIB "))
{
// flip video
uint8_t *extraData = new uint8_t[_videoExtraLen + 9];
memcpy(extraData, _videoExtraData, _videoExtraLen);
memcpy(extraData + _videoExtraLen, "BottomUp", 9);
delete [] _videoExtraData;
_videoExtraLen += 9;
_videoExtraData = extraData;
_videostream.fccHandler = _video_bih.biCompression = fourCC::get((uint8_t*)"DIB ");
}
else
_videostream.fccHandler=_video_bih.biCompression;
printf("\nOpenDML file successfully read..\n");
return ret;
}
/*
Recursively climb a riff tree and not where are
the interesting informations to be read later on
*/
void OpenDMLHeader::walk(riffParser *p)
{
uint32_t fcc,len;
static uint32_t nest=0;
nest++;
while(!p->endReached())
{
fcc=p->read32();
len=p->read32();
#ifdef OPENDML_VERBOSE
for(uint j=0;j<nest;j++) aprintf("\t");
PAD;
aprintf("Entry :");fourCC::print(fcc);aprintf(" Size: %lu (%lx)\n",len,len);
#endif
switch(fcc)
{
case MKFCC('a','v','i','h'):
aprintf("main header found \n");
if(len!=sizeof(_mainaviheader))
{
printf("oops : %d / %d\n",len,sizeof(_mainaviheader));
}
p->read(len,(uint8_t *)&_mainaviheader);
#ifdef ADM_BIG_ENDIAN
Endian_AviMainHeader(&_mainaviheader);
#endif
printf("\n Main avi header :\n");
break;
case MKFCC('i','d','x','1'):
_regularIndex.offset=p->getPos();
printf("Idx1 found at offset %"LLX"\n",_regularIndex.offset);
_regularIndex.size=len;
return;
break;
case MKFCC('R','I','F','F'):
uint32_t sublen;
p->read32();
{
riffParser *n;
n=new riffParser(p,len-4);
walk(n);
delete n;
}
p->curPos=ftello(p->fd);
break;
case MKFCC('s','t','r','f'):
_Tracks[_nbTrack].strf.offset=p->getPos();
_Tracks[_nbTrack].strf.size=len;
p->skip(len);
DUMP_TRACK(_nbTrack);
break;
case MKFCC('s','t','r','h'):
_Tracks[_nbTrack].strh.offset=p->getPos();
_Tracks[_nbTrack].strh.size=len;
p->skip(len);
DUMP_TRACK(_nbTrack);
break;
case MKFCC('i','n','d','x'):
printf("Indx found for track %d\n",_nbTrack);
_Tracks[_nbTrack].indx.offset=p->getPos();
_Tracks[_nbTrack].indx.size=len;
p->skip(len);
break;
case MKFCC('L','I','S','T'):
{
uint32_t sub,l;
PAD;
aprintf("\tType:");
sub=p->read32();
len-=4;
#ifdef OPENDML_VERBOSE
fourCC::print(sub);printf(" (%d bytes to go)\n",len);
#endif
if(sub==MKFCC('m','o','v','i'))
{
_movi.offset=p->getPos();
p->skip(len);
}
else
{
riffParser *n;
n=new riffParser(p,len);
walk(n);
delete n;
}
p->curPos=ftello(p->fd);
if(MKFCC('s','t','r','l')==sub)
{
_nbTrack++;
}
}
break;
default:
PAD;
aprintf("\tskipping %lu bytes\n");
p->skip(len);
break;
}
}
nest--;
}
/**
\fn encode
*/
bool ADM_ffMpeg2Encoder::encode (ADMBitstream * out)
{
int sz,q;
int gotData;
int r;
again:
sz=0;
if(false==preEncode()) // Pop - out the frames stored in the queue due to B-frames
{
AVPacket pkt;
av_init_packet(&pkt);
pkt.data=out->data;
pkt.size=out->bufferSize;
r=encodeWrapper(NULL,out);
if(r<0)
{
ADM_warning("[ffMpeg2] Error %d encoding video\n",r);
return false;
}
sz=r;
ADM_info("[ffMpeg2] Popping delayed bframes (%d)\n",sz);
goto link;
return false;
}
q=image->_Qp;
if(!q) q=2;
switch(Settings.params.mode)
{
case COMPRESS_SAME:
// Keep same frame type & same Qz as the incoming frame...
_frame->quality = (int) floor (FF_QP2LAMBDA * q+ 0.5);
if(image->flags & AVI_KEY_FRAME) _frame->pict_type = AV_PICTURE_TYPE_I;
else if(image->flags & AVI_B_FRAME) _frame->pict_type = AV_PICTURE_TYPE_B;
else _frame->pict_type = AV_PICTURE_TYPE_P;
break;
case COMPRESS_2PASS:
case COMPRESS_2PASS_BITRATE:
switch(pass)
{
case 1:
break;
case 2:
break; // Get Qz for this frame...
}
case COMPRESS_CQ:
_frame->quality = (int) floor (FF_QP2LAMBDA * Settings.params.qz+ 0.5);
break;
case COMPRESS_CBR:
break;
default:
printf("[ffMpeg2] Unsupported encoding mode\n");
return false;
}
aprintf("[CODEC] Flags = 0x%x, QSCALE=%x, bit_rate=%d, quality=%d qz=%d incoming qz=%d\n",_context->flags,CODEC_FLAG_QSCALE,
_context->bit_rate, _frame->quality, _frame->quality/ FF_QP2LAMBDA,q);
_frame->reordered_opaque=image->Pts;
r=encodeWrapper(_frame,out);
if(r<0)
{
ADM_warning("[ffMpeg2] Error %d encoding video\n",r);
return false;
}
sz=r;
if(sz==0) // no pic, probably pre filling, try again
goto again;
link:
return postEncode(out,sz);
}
CURLcode Curl_nss_connect(struct connectdata *conn, int sockindex)
{
PRErrorCode err = 0;
PRFileDesc *model = NULL;
PRBool ssl2 = PR_FALSE;
PRBool ssl3 = PR_FALSE;
PRBool tlsv1 = PR_FALSE;
PRBool ssl_no_cache;
PRBool ssl_cbc_random_iv;
struct SessionHandle *data = conn->data;
curl_socket_t sockfd = conn->sock[sockindex];
struct ssl_connect_data *connssl = &conn->ssl[sockindex];
CURLcode curlerr;
const int *cipher_to_enable;
PRSocketOptionData sock_opt;
long time_left;
PRUint32 timeout;
if(connssl->state == ssl_connection_complete)
return CURLE_OK;
connssl->data = data;
/* list of all NSS objects we need to destroy in Curl_nss_close() */
connssl->obj_list = Curl_llist_alloc(nss_destroy_object);
if(!connssl->obj_list)
return CURLE_OUT_OF_MEMORY;
/* FIXME. NSS doesn't support multiple databases open at the same time. */
PR_Lock(nss_initlock);
curlerr = nss_init(conn->data);
if(CURLE_OK != curlerr) {
PR_Unlock(nss_initlock);
goto error;
}
curlerr = CURLE_SSL_CONNECT_ERROR;
if(!mod) {
char *configstring = aprintf("library=%s name=PEM", pem_library);
if(!configstring) {
PR_Unlock(nss_initlock);
goto error;
}
mod = SECMOD_LoadUserModule(configstring, NULL, PR_FALSE);
free(configstring);
if(!mod || !mod->loaded) {
if(mod) {
SECMOD_DestroyModule(mod);
mod = NULL;
}
infof(data, "WARNING: failed to load NSS PEM library %s. Using "
"OpenSSL PEM certificates will not work.\n", pem_library);
}
}
PK11_SetPasswordFunc(nss_get_password);
PR_Unlock(nss_initlock);
model = PR_NewTCPSocket();
if(!model)
goto error;
model = SSL_ImportFD(NULL, model);
/* make the socket nonblocking */
sock_opt.option = PR_SockOpt_Nonblocking;
sock_opt.value.non_blocking = PR_TRUE;
if(PR_SetSocketOption(model, &sock_opt) != PR_SUCCESS)
goto error;
if(SSL_OptionSet(model, SSL_SECURITY, PR_TRUE) != SECSuccess)
goto error;
if(SSL_OptionSet(model, SSL_HANDSHAKE_AS_SERVER, PR_FALSE) != SECSuccess)
goto error;
if(SSL_OptionSet(model, SSL_HANDSHAKE_AS_CLIENT, PR_TRUE) != SECSuccess)
goto error;
/* do not use SSL cache if we are not going to verify peer */
ssl_no_cache = (data->set.ssl.verifypeer) ? PR_FALSE : PR_TRUE;
if(SSL_OptionSet(model, SSL_NO_CACHE, ssl_no_cache) != SECSuccess)
goto error;
switch (data->set.ssl.version) {
default:
case CURL_SSLVERSION_DEFAULT:
ssl3 = PR_TRUE;
if(data->state.ssl_connect_retry)
infof(data, "TLS disabled due to previous handshake failure\n");
else
tlsv1 = PR_TRUE;
break;
case CURL_SSLVERSION_TLSv1:
tlsv1 = PR_TRUE;
break;
case CURL_SSLVERSION_SSLv2:
ssl2 = PR_TRUE;
break;
case CURL_SSLVERSION_SSLv3:
ssl3 = PR_TRUE;
break;
}
if(SSL_OptionSet(model, SSL_ENABLE_SSL2, ssl2) != SECSuccess)
goto error;
if(SSL_OptionSet(model, SSL_ENABLE_SSL3, ssl3) != SECSuccess)
goto error;
if(SSL_OptionSet(model, SSL_ENABLE_TLS, tlsv1) != SECSuccess)
goto error;
if(SSL_OptionSet(model, SSL_V2_COMPATIBLE_HELLO, ssl2) != SECSuccess)
goto error;
ssl_cbc_random_iv = !data->set.ssl_enable_beast;
#ifdef SSL_CBC_RANDOM_IV
/* unless the user explicitly asks to allow the protocol vulnerability, we
use the work-around */
if(SSL_OptionSet(model, SSL_CBC_RANDOM_IV, ssl_cbc_random_iv) != SECSuccess)
infof(data, "warning: failed to set SSL_CBC_RANDOM_IV = %d\n",
ssl_cbc_random_iv);
#else
if(ssl_cbc_random_iv)
infof(data, "warning: support for SSL_CBC_RANDOM_IV not compiled in\n");
#endif
/* reset the flag to avoid an infinite loop */
data->state.ssl_connect_retry = FALSE;
/* enable all ciphers from enable_ciphers_by_default */
cipher_to_enable = enable_ciphers_by_default;
while(SSL_NULL_WITH_NULL_NULL != *cipher_to_enable) {
if(SSL_CipherPrefSet(model, *cipher_to_enable, PR_TRUE) != SECSuccess) {
curlerr = CURLE_SSL_CIPHER;
goto error;
}
cipher_to_enable++;
}
if(data->set.ssl.cipher_list) {
if(set_ciphers(data, model, data->set.ssl.cipher_list) != SECSuccess) {
curlerr = CURLE_SSL_CIPHER;
goto error;
}
}
if(!data->set.ssl.verifypeer && data->set.ssl.verifyhost)
infof(data, "warning: ignoring value of ssl.verifyhost\n");
/* bypass the default SSL_AuthCertificate() hook in case we do not want to
* verify peer */
if(SSL_AuthCertificateHook(model, nss_auth_cert_hook, conn) != SECSuccess)
goto error;
data->set.ssl.certverifyresult=0; /* not checked yet */
if(SSL_BadCertHook(model, BadCertHandler, conn) != SECSuccess)
goto error;
if(SSL_HandshakeCallback(model, HandshakeCallback, NULL) != SECSuccess)
goto error;
if(data->set.ssl.verifypeer) {
const CURLcode rv = nss_load_ca_certificates(conn, sockindex);
if(CURLE_OK != rv) {
curlerr = rv;
goto error;
}
}
if(data->set.ssl.CRLfile) {
if(SECSuccess != nss_load_crl(data->set.ssl.CRLfile)) {
curlerr = CURLE_SSL_CRL_BADFILE;
goto error;
}
infof(data,
" CRLfile: %s\n",
data->set.ssl.CRLfile ? data->set.ssl.CRLfile : "none");
}
if(data->set.str[STRING_CERT]) {
char *nickname = dup_nickname(data, STRING_CERT);
if(nickname) {
/* we are not going to use libnsspem.so to read the client cert */
connssl->obj_clicert = NULL;
}
else {
CURLcode rv = cert_stuff(conn, sockindex, data->set.str[STRING_CERT],
data->set.str[STRING_KEY]);
if(CURLE_OK != rv) {
/* failf() is already done in cert_stuff() */
curlerr = rv;
goto error;
}
}
/* store the nickname for SelectClientCert() called during handshake */
connssl->client_nickname = nickname;
}
else
connssl->client_nickname = NULL;
if(SSL_GetClientAuthDataHook(model, SelectClientCert,
(void *)connssl) != SECSuccess) {
curlerr = CURLE_SSL_CERTPROBLEM;
goto error;
}
/* Import our model socket onto the existing file descriptor */
connssl->handle = PR_ImportTCPSocket(sockfd);
connssl->handle = SSL_ImportFD(model, connssl->handle);
if(!connssl->handle)
goto error;
PR_Close(model); /* We don't need this any more */
model = NULL;
/* This is the password associated with the cert that we're using */
if(data->set.str[STRING_KEY_PASSWD]) {
SSL_SetPKCS11PinArg(connssl->handle, data->set.str[STRING_KEY_PASSWD]);
}
/* Force handshake on next I/O */
SSL_ResetHandshake(connssl->handle, /* asServer */ PR_FALSE);
SSL_SetURL(connssl->handle, conn->host.name);
/* check timeout situation */
time_left = Curl_timeleft(data, NULL, TRUE);
if(time_left < 0L) {
failf(data, "timed out before SSL handshake");
curlerr = CURLE_OPERATION_TIMEDOUT;
goto error;
}
timeout = PR_MillisecondsToInterval((PRUint32) time_left);
/* Force the handshake now */
if(SSL_ForceHandshakeWithTimeout(connssl->handle, timeout) != SECSuccess) {
if(conn->data->set.ssl.certverifyresult == SSL_ERROR_BAD_CERT_DOMAIN)
curlerr = CURLE_PEER_FAILED_VERIFICATION;
else if(conn->data->set.ssl.certverifyresult!=0)
curlerr = CURLE_SSL_CACERT;
goto error;
}
connssl->state = ssl_connection_complete;
conn->recv[sockindex] = nss_recv;
conn->send[sockindex] = nss_send;
display_conn_info(conn, connssl->handle);
if(data->set.str[STRING_SSL_ISSUERCERT]) {
SECStatus ret = SECFailure;
char *nickname = dup_nickname(data, STRING_SSL_ISSUERCERT);
if(nickname) {
/* we support only nicknames in case of STRING_SSL_ISSUERCERT for now */
ret = check_issuer_cert(connssl->handle, nickname);
free(nickname);
}
if(SECFailure == ret) {
infof(data,"SSL certificate issuer check failed\n");
curlerr = CURLE_SSL_ISSUER_ERROR;
goto error;
}
else {
infof(data, "SSL certificate issuer check ok\n");
}
}
return CURLE_OK;
error:
/* reset the flag to avoid an infinite loop */
data->state.ssl_connect_retry = FALSE;
if(is_nss_error(curlerr)) {
/* read NSPR error code */
err = PR_GetError();
if(is_cc_error(err))
curlerr = CURLE_SSL_CERTPROBLEM;
/* print the error number and error string */
infof(data, "NSS error %d (%s)\n", err, nss_error_to_name(err));
/* print a human-readable message describing the error if available */
nss_print_error_message(data, err);
}
if(model)
PR_Close(model);
/* cleanup on connection failure */
Curl_llist_destroy(connssl->obj_list, NULL);
connssl->obj_list = NULL;
if(ssl3 && tlsv1 && isTLSIntoleranceError(err)) {
/* schedule reconnect through Curl_retry_request() */
data->state.ssl_connect_retry = TRUE;
infof(data, "Error in TLS handshake, trying SSLv3...\n");
return CURLE_OK;
}
return curlerr;
}
/**
\fn GenericAviSaveCopyUnpack::setupVideo
\brief init for unpacker code
*/
uint8_t GenericAviSaveCopyPack::writeVideoChunk (uint32_t frame)
{
uint8_t ret1;
ADMCompressedImage img;
uint32_t oldtimeinc=0;
img.data=vbuffer;
if(!video_body->isReordered(frameStart+frame))
{
ret1 = video_body->getFrameNoAlloc (frameStart + frame,&img);
_videoFlag=img.flags;
}
else
{
ret1=1;
// We prefetch one frame...
if(!frame) // First frame.
{
if(!prefetch(0,frame))
{
return 0;
}
curToggle=0;
}
uint32_t len=0;
ADMBitstream *current,*next;
current=lookAhead[curToggle];
next=lookAhead[curToggle^1];
if(current->flags!=AVI_B_FRAME && current->flags!=1)
{
/* Get its timecode */
if(!getTimeCode(current,time_inc,&oldtimeinc))
{
printf("WARNING cannot get timecode for frame %u\n",frame);
}
}
if(frame+2<_incoming->getInfo()->nb_frames)
{
if( !prefetch(curToggle^1,frame+1))
{
return 0;
}
// Curtoggle holds the current frame, curToggle ^1 hold the next frame
if(current->flags!=1 && current->flags!=AVI_B_FRAME && next->flags==AVI_B_FRAME)
{
aprintf("Packing frame :%u\n",frame);
// We need to pack this
len=current->len;
memcpy(vbuffer,current->data,len);
memcpy(vbuffer+len,next->data,next->len);
len+=next->len;
img.dataLength=len;
// Put nvop in next buffer
putNvop(next,time_inc, oldtimeinc);
next->flags=1; // Mark it as P, so that we can identify it later
}else
{
// Just send
len=current->len;
memcpy(vbuffer,current->data,len);
}
}
else
{
// Last frame
aprintf("Last frame\n");
len= current->len;
memcpy(vbuffer,current->data,len);
}
img.dataLength=len;
if(current->flags==1) current->flags=0; // Remove our marker
_videoFlag=img.flags=current->flags;
if(_videoFlag==AVI_KEY_FRAME)
{
updateUserData(vbuffer,len);
}
curToggle^=1;
}
if (!ret1)
return 0;
if(_videoFlag==AVI_KEY_FRAME)
newFile();
aprintf("Writting frame %u size %u flags %x\n",frame,img.dataLength,_videoFlag);
encoding_gui->setFrame(frame,img.dataLength,0,frametogo);
return writter->saveVideoFrame (img.dataLength, img.flags, img.data);
}
void myprintf(void)
{
printf("myprintf_call\r\n");
aprintf();
printf("myprintf_function is running!\r\n");
}
uint8_t
EncoderRequant::encode (uint32_t frame, ADMBitstream *out)
{
uint8_t ret = 0;
out->dtsFrame = frame;
if (frame >= _total)
{
printf ("[Requant]: Going out of bound %d/%d\n", frame, _total);
// Stuff with emptyness
out->len=0;
return 1;
}
out->flags=0;
/* First frame ? */
// No B frames, take as is
if (!video_body->isReordered (frameStart + frame))
{
ret =code(_frameStart + frame, out->data, &out->len);
out->ptsFrame = frame;
return ret;
}
// it has PTS/DTS stuff so we need to reorder it
video_body->getFlags (frameStart + frame, &(out->flags));
if (out->flags & AVI_B_FRAME)
{ // search if we have to send a I/P frame in adance
aprintf ("\tIt is a B frame\n");
uint32_t forward;
forward = searchForward (_frameStart + frame);
// if we did not sent it, do it now
if (forward != _lastIPFrameSent)
{
aprintf ("\tP Frame not sent, sending it :%lu\n", forward);
ret =code(forward, out->data, &out->len);
//ret = video_body->getRaw (forward, out->data, &out->len);
_lastIPFrameSent = forward;
out->ptsFrame = forward - _frameStart;
}
else
{
// we already sent it :)
// send n-1
aprintf ("\tP Frame already, sending :%lu\n",
frameStart + frame - 1);
ret =code(_frameStart + frame - 1, out->data, &out->len);
// ret =video_body->getFrameNoAlloc (_frameStart + frame - 1, out->data,
// &out->len,&out->flags);
out->ptsFrame = frame - 1;
}
}
else // it is not a B frame and we have nothing on hold, sent it..
{
// send n-1 if we reach the fwd reference frame
if ((frame + frameStart) == _lastIPFrameSent)
{
aprintf ("\tSending Last B-frame :(%lu)\n",
_frameStart + frame - 1);
//ret=video_body->getFrameNoAlloc (_frameStart+frame - 1,out->data,&out->len,&out->flags);
ret =code(_frameStart + frame - 1, out->data, &out->len);
out->ptsFrame = frame - 1;
}
else
{
aprintf ("\tJust sending it :(%lu)-(%lu)\n", _frameStart + frame,
_lastIPFrameSent);
ret =code(_frameStart + frame , out->data, &out->len);
// ret=video_body->getFrameNoAlloc (_frameStart+frame, out->data,&out->len,&out->flags);
out->ptsFrame = frame;
if(!frame) // First frame ?
{
// It does not start by a seqstart, add it if possible
if(!(_buffer[0]==0 && _buffer[1]==0 && _buffer[2]==1 && _buffer[3]==0xb3))
{
uint8_t buf[10*1024];
uint32_t seq;
video_body->getRawStart (frameStart, buf, &seq);
printf("Adding seq header (%lu)\n",seq);
memmove(_buffer+seq,_buffer,out->len);
memcpy(_buffer,buf,seq);
out->len+=seq;
}
}
}
}
if (!ret)
printf ("Get frame error for frame %d+%d\n", frameStart, frame);
return ret;
}
bool ADM_ffVAEncHEVC::preEncode(void)
{
uint32_t nb;
if(source->getNextFrame(&nb,image)==false)
{
ADM_warning("[ffVAEncHEVC] Cannot get next image\n");
return false;
}
swFrame=av_frame_alloc();
if(!swFrame)
{
ADM_error("Could not allocate sw frame\n");
return false;
}
swFrame->width=source->getInfo()->width;
swFrame->height=source->getInfo()->height;
swFrame->format=AV_PIX_FMT_NV12;
int err=av_frame_get_buffer(swFrame, 32);
if(err<0)
{
CLEARTEXT(err)
ADM_warning("get buffer for sw frame failed with error code %d (%s)\n",err,buf);
return false;
}
swFrame->linesize[0] = swFrame->linesize[1] = image->GetPitch(PLANAR_Y);
swFrame->linesize[2] = 0;
swFrame->data[2] = NULL;
image->convertToNV12(swFrame->data[0],swFrame->data[1],swFrame->linesize[0],swFrame->linesize[1]);
if(hwFrame)
{
av_frame_free(&hwFrame);
hwFrame=NULL;
}
hwFrame=av_frame_alloc();
if(!hwFrame)
{
ADM_error("Could not allocate hw frame\n");
return false;
}
hwFrame->width=source->getInfo()->width;
hwFrame->height=source->getInfo()->height;
hwFrame->format=AV_PIX_FMT_VAAPI;
err=av_hwframe_get_buffer(_context->hw_frames_ctx,hwFrame,0);
if(err<0)
{
CLEARTEXT(err)
ADM_warning("get buffer for hw frame failed with error code %d (%s)\n",err,buf);
return false;
}
err=av_hwframe_transfer_data(hwFrame, swFrame, 0);
if(err<0)
{
CLEARTEXT(err)
ADM_warning("data transfer to the hw frame failed with error code %d (%s)\n",err,buf);
return false;
}
uint64_t p=image->Pts;
queueOfDts.push_back(p);
aprintf("Incoming frame PTS=%" PRIu64", delay=%" PRIu64"\n",p,getEncoderDelay());
p+=getEncoderDelay();
hwFrame->pts=timingToLav(p);
if(!hwFrame->pts)
hwFrame->pts=AV_NOPTS_VALUE;
ADM_timeMapping map; // Store real PTS <->lav value mapping
map.realTS=p;
map.internalTS=hwFrame->pts;
mapper.push_back(map);
av_frame_free(&swFrame);
swFrame=NULL;
return true;
}
/* Start the DO phase */
static CURLcode smtp_mail(struct connectdata *conn)
{
char *from = NULL;
char *auth = NULL;
char *size = NULL;
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
/* Calculate the FROM parameter */
if(!data->set.str[STRING_MAIL_FROM])
/* Null reverse-path, RFC-2821, sect. 3.7 */
from = strdup("<>");
else if(data->set.str[STRING_MAIL_FROM][0] == '<')
from = aprintf("%s", data->set.str[STRING_MAIL_FROM]);
else
from = aprintf("<%s>", data->set.str[STRING_MAIL_FROM]);
if(!from)
return CURLE_OUT_OF_MEMORY;
/* Calculate the optional AUTH parameter */
if(data->set.str[STRING_MAIL_AUTH] && conn->proto.smtpc.authused) {
if(data->set.str[STRING_MAIL_AUTH][0] != '\0')
auth = aprintf("%s", data->set.str[STRING_MAIL_AUTH]);
else
/* Empty AUTH, RFC-2554, sect. 5 */
auth = strdup("<>");
if(!auth) {
Curl_safefree(from);
return CURLE_OUT_OF_MEMORY;
}
}
/* calculate the optional SIZE parameter */
if(conn->proto.smtpc.size_supported && conn->data->set.infilesize > 0) {
size = aprintf("%" FORMAT_OFF_T, data->set.infilesize);
if(!size) {
Curl_safefree(from);
Curl_safefree(auth);
return CURLE_OUT_OF_MEMORY;
}
}
/* Send the MAIL command */
if(!auth && !size)
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s", from);
else if(auth && !size)
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s AUTH=%s", from, auth);
else if(auth && size)
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s AUTH=%s SIZE=%s", from, auth, size);
else
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s SIZE=%s", from, size);
Curl_safefree(from);
Curl_safefree(auth);
Curl_safefree(size);
if(result)
return result;
state(conn, SMTP_MAIL);
return result;
}
/*----------------------------------------------*/
uint8_t DIA_resize(uint32_t *width,uint32_t *height,uint32_t *alg,uint32_t originalw, uint32_t originalh,uint32_t fps1000)
{
char str[100];
uint8_t ret=0;
if(fps1000>24600 && fps1000<25400)
{
aprintf("Pal\n");
pal=1;
}
else
{
aprintf("NTSC\n");
pal=0;
}
ow=originalw;
oh=originalh;
iw=*width;
ih=*height;
dialog=create_dialog1();
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
GTK_RESPONSE_APPLY,
-1);
//gtk_transient(dialog);
gtk_register_dialog(dialog);
erx=ery=0;
double val;
val=100.*iw;
if(ow) val=val/ow;
adj_angle= gtk_range_get_adjustment (GTK_RANGE(WID(hscale1)));
gtk_adjustment_set_value( GTK_ADJUSTMENT(adj_angle),( gdouble ) val );
// remember algo
gtk_option_menu_set_history (GTK_OPTION_MENU (WID(optionmenu1)), *alg);
#define CONNECT(w,x) gtk_signal_connect(GTK_OBJECT(lookup_widget(dialog,#w)), #x, \
GTK_SIGNAL_FUNC(drag), NULL)
CONNECT(hscale1,drag_data_received);
CONNECT(hscale1,drag_motion);
CONNECT(hscale1,drag_data_get);
CONNECT(hscale1,drag_begin);
gtk_signal_connect(GTK_OBJECT(adj_angle),"value_changed", GTK_SIGNAL_FUNC(drag), NULL);
write();
ret=0;
uint8_t stop=0;
while(!stop)
{
switch(gtk_dialog_run(GTK_DIALOG(dialog)))
{
case GTK_RESPONSE_OK:
gchar *s;
SPIN_GET(spinbutton_width,*width);
SPIN_GET(spinbutton_height,*height);
*alg= getRangeInMenu(lookup_widget(dialog,"optionmenu1"));
ret=1;
stop=1;
break;
default:
case GTK_RESPONSE_CANCEL:
stop=1;
break;
case GTK_RESPONSE_APPLY:
drag(NULL,NULL);
break;
}
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return ret;
}
/*
* This is for creating ntlm header output
*/
CURLcode Curl_output_ntlm(struct connectdata *conn,
bool proxy)
{
char *base64 = NULL;
size_t len = 0;
CURLcode error;
/* point to the address of the pointer that holds the string to send to the
server, which is for a plain host or for a HTTP proxy */
char **allocuserpwd;
/* point to the name and password for this */
const char *userp;
const char *passwdp;
/* point to the correct struct with this */
struct ntlmdata *ntlm;
struct auth *authp;
DEBUGASSERT(conn);
DEBUGASSERT(conn->data);
#ifdef USE_NSS
if(CURLE_OK != Curl_nss_force_init(conn->data))
return CURLE_OUT_OF_MEMORY;
#endif
if(proxy) {
allocuserpwd = &conn->allocptr.proxyuserpwd;
userp = conn->proxyuser;
passwdp = conn->proxypasswd;
ntlm = &conn->proxyntlm;
authp = &conn->data->state.authproxy;
}
else {
allocuserpwd = &conn->allocptr.userpwd;
userp = conn->user;
passwdp = conn->passwd;
ntlm = &conn->ntlm;
authp = &conn->data->state.authhost;
}
authp->done = FALSE;
/* not set means empty */
if(!userp)
userp = "";
if(!passwdp)
passwdp = "";
#ifdef USE_WINDOWS_SSPI
if(s_hSecDll == NULL) {
/* not thread safe and leaks - use curl_global_init() to avoid */
CURLcode err = Curl_sspi_global_init();
if(s_hSecDll == NULL)
return err;
}
#endif
switch(ntlm->state) {
case NTLMSTATE_TYPE1:
default: /* for the weird cases we (re)start here */
/* Create a type-1 message */
error = Curl_ntlm_create_type1_message(userp, passwdp, ntlm, &base64,
&len);
if(error)
return error;
if(base64) {
Curl_safefree(*allocuserpwd);
*allocuserpwd = aprintf("%sAuthorization: NTLM %s\r\n",
proxy ? "Proxy-" : "",
base64);
free(base64);
if(!*allocuserpwd)
return CURLE_OUT_OF_MEMORY;
DEBUG_OUT(fprintf(stderr, "**** Header %s\n ", *allocuserpwd));
}
break;
case NTLMSTATE_TYPE2:
/* We already received the type-2 message, create a type-3 message */
error = Curl_ntlm_create_type3_message(conn->data, userp, passwdp,
ntlm, &base64, &len);
if(error)
return error;
if(base64) {
Curl_safefree(*allocuserpwd);
*allocuserpwd = aprintf("%sAuthorization: NTLM %s\r\n",
proxy ? "Proxy-" : "",
base64);
free(base64);
if(!*allocuserpwd)
return CURLE_OUT_OF_MEMORY;
DEBUG_OUT(fprintf(stderr, "**** %s\n ", *allocuserpwd));
ntlm->state = NTLMSTATE_TYPE3; /* we send a type-3 */
authp->done = TRUE;
}
break;
case NTLMSTATE_TYPE3:
/* connection is already authenticated,
* don't send a header in future requests */
Curl_safefree(*allocuserpwd);
authp->done = TRUE;
break;
}
return CURLE_OK;
}
/***********************************************************************
*
* smtp_perform_mail()
*
* Sends an MAIL command to initiate the upload of a message.
*/
static CURLcode smtp_perform_mail(struct connectdata *conn)
{
char *from = NULL;
char *auth = NULL;
char *size = NULL;
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
/* Calculate the FROM parameter */
if(!data->set.str[STRING_MAIL_FROM])
/* Null reverse-path, RFC-5321, sect. 3.6.3 */
from = strdup("<>");
else if(data->set.str[STRING_MAIL_FROM][0] == '<')
from = aprintf("%s", data->set.str[STRING_MAIL_FROM]);
else
from = aprintf("<%s>", data->set.str[STRING_MAIL_FROM]);
if(!from)
return CURLE_OUT_OF_MEMORY;
/* Calculate the optional AUTH parameter */
if(data->set.str[STRING_MAIL_AUTH] && conn->proto.smtpc.sasl.authused) {
if(data->set.str[STRING_MAIL_AUTH][0] != '\0')
auth = aprintf("%s", data->set.str[STRING_MAIL_AUTH]);
else
/* Empty AUTH, RFC-2554, sect. 5 */
auth = strdup("<>");
if(!auth) {
free(from);
return CURLE_OUT_OF_MEMORY;
}
}
/* Prepare the mime data if some. */
if(data->set.mimepost.kind != MIMEKIND_NONE) {
/* Use the whole structure as data. */
data->set.mimepost.flags &= ~MIME_BODY_ONLY;
/* Add external headers and mime version. */
curl_mime_headers(&data->set.mimepost, data->set.headers, 0);
result = Curl_mime_prepare_headers(&data->set.mimepost, NULL,
NULL, MIMESTRATEGY_MAIL);
if(!result)
if(!Curl_checkheaders(conn, "Mime-Version"))
result = Curl_mime_add_header(&data->set.mimepost.curlheaders,
"Mime-Version: 1.0");
/* Make sure we will read the entire mime structure. */
if(!result)
result = Curl_mime_rewind(&data->set.mimepost);
if(result) {
free(from);
free(auth);
return result;
}
data->state.infilesize = Curl_mime_size(&data->set.mimepost);
/* Read from mime structure. */
data->state.fread_func = (curl_read_callback) Curl_mime_read;
data->state.in = (void *) &data->set.mimepost;
}
/* Calculate the optional SIZE parameter */
if(conn->proto.smtpc.size_supported && data->state.infilesize > 0) {
size = aprintf("%" CURL_FORMAT_CURL_OFF_T, data->state.infilesize);
if(!size) {
free(from);
free(auth);
return CURLE_OUT_OF_MEMORY;
}
}
/* Send the MAIL command */
if(!auth && !size)
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s", from);
else if(auth && !size)
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s AUTH=%s", from, auth);
else if(auth && size)
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s AUTH=%s SIZE=%s", from, auth, size);
else
result = Curl_pp_sendf(&conn->proto.smtpc.pp,
"MAIL FROM:%s SIZE=%s", from, size);
free(from);
free(auth);
free(size);
if(!result)
state(conn, SMTP_MAIL);
return result;
}
CURLcode Curl_proxyCONNECT(struct connectdata *conn,
int sockindex,
const char *hostname,
unsigned short remote_port)
{
int subversion=0;
struct SessionHandle *data=conn->data;
struct SingleRequest *k = &data->req;
CURLcode result;
long timeout =
data->set.timeout?data->set.timeout:PROXY_TIMEOUT; /* in milliseconds */
curl_socket_t tunnelsocket = conn->sock[sockindex];
curl_off_t cl=0;
bool closeConnection = FALSE;
bool chunked_encoding = FALSE;
long check;
#define SELECT_OK 0
#define SELECT_ERROR 1
#define SELECT_TIMEOUT 2
int error = SELECT_OK;
if(conn->tunnel_state[sockindex] == TUNNEL_COMPLETE)
return CURLE_OK; /* CONNECT is already completed */
conn->bits.proxy_connect_closed = FALSE;
do {
if(TUNNEL_INIT == conn->tunnel_state[sockindex]) {
/* BEGIN CONNECT PHASE */
char *host_port;
Curl_send_buffer *req_buffer;
infof(data, "Establish HTTP proxy tunnel to %s:%hu\n",
hostname, remote_port);
if(data->req.newurl) {
/* This only happens if we've looped here due to authentication
reasons, and we don't really use the newly cloned URL here
then. Just free() it. */
free(data->req.newurl);
data->req.newurl = NULL;
}
/* initialize a dynamic send-buffer */
req_buffer = Curl_add_buffer_init();
if(!req_buffer)
return CURLE_OUT_OF_MEMORY;
host_port = aprintf("%s:%hu", hostname, remote_port);
if(!host_port) {
free(req_buffer);
return CURLE_OUT_OF_MEMORY;
}
/* Setup the proxy-authorization header, if any */
result = Curl_http_output_auth(conn, "CONNECT", host_port, TRUE);
free(host_port);
if(CURLE_OK == result) {
char *host=(char *)"";
const char *proxyconn="";
const char *useragent="";
const char *http = (conn->proxytype == CURLPROXY_HTTP_1_0) ?
"1.0" : "1.1";
char *hostheader= /* host:port with IPv6 support */
aprintf("%s%s%s:%hu", conn->bits.ipv6_ip?"[":"",
hostname, conn->bits.ipv6_ip?"]":"",
remote_port);
if(!hostheader) {
free(req_buffer);
return CURLE_OUT_OF_MEMORY;
}
if(!Curl_checkheaders(data, "Host:")) {
host = aprintf("Host: %s\r\n", hostheader);
if(!host) {
free(hostheader);
free(req_buffer);
return CURLE_OUT_OF_MEMORY;
}
}
if(!Curl_checkheaders(data, "Proxy-Connection:"))
proxyconn = "Proxy-Connection: Keep-Alive\r\n";
if(!Curl_checkheaders(data, "User-Agent:") &&
data->set.str[STRING_USERAGENT])
useragent = conn->allocptr.uagent;
result =
Curl_add_bufferf(req_buffer,
"CONNECT %s HTTP/%s\r\n"
"%s" /* Host: */
"%s" /* Proxy-Authorization */
"%s" /* User-Agent */
"%s", /* Proxy-Connection */
hostheader,
http,
host,
conn->allocptr.proxyuserpwd?
conn->allocptr.proxyuserpwd:"",
useragent,
proxyconn);
if(host && *host)
free(host);
free(hostheader);
if(CURLE_OK == result)
result = Curl_add_custom_headers(conn, req_buffer);
if(CURLE_OK == result)
/* CRLF terminate the request */
result = Curl_add_bufferf(req_buffer, "\r\n");
if(CURLE_OK == result) {
/* Send the connect request to the proxy */
/* BLOCKING */
result =
Curl_add_buffer_send(req_buffer, conn,
&data->info.request_size, 0, sockindex);
}
req_buffer = NULL;
if(result)
failf(data, "Failed sending CONNECT to proxy");
}
Curl_safefree(req_buffer);
if(result)
return result;
conn->tunnel_state[sockindex] = TUNNEL_CONNECT;
/* now we've issued the CONNECT and we're waiting to hear back, return
and get called again polling-style */
return CURLE_OK;
} /* END CONNECT PHASE */
{ /* BEGIN NEGOTIATION PHASE */
size_t nread; /* total size read */
int perline; /* count bytes per line */
int keepon=TRUE;
ssize_t gotbytes;
char *ptr;
char *line_start;
ptr=data->state.buffer;
line_start = ptr;
nread=0;
perline=0;
keepon=TRUE;
while((nread<BUFSIZE) && (keepon && !error)) {
/* if timeout is requested, find out how much remaining time we have */
check = timeout - /* timeout time */
Curl_tvdiff(Curl_tvnow(), conn->now); /* spent time */
if(check <= 0) {
failf(data, "Proxy CONNECT aborted due to timeout");
error = SELECT_TIMEOUT; /* already too little time */
break;
}
/* loop every second at least, less if the timeout is near */
switch (Curl_socket_ready(tunnelsocket, CURL_SOCKET_BAD,
check<1000L?check:1000)) {
case -1: /* select() error, stop reading */
error = SELECT_ERROR;
failf(data, "Proxy CONNECT aborted due to select/poll error");
break;
case 0: /* timeout */
break;
default:
DEBUGASSERT(ptr+BUFSIZE-nread <= data->state.buffer+BUFSIZE+1);
result = Curl_read(conn, tunnelsocket, ptr, BUFSIZE-nread,
&gotbytes);
if(result==CURLE_AGAIN)
continue; /* go loop yourself */
else if(result)
keepon = FALSE;
else if(gotbytes <= 0) {
keepon = FALSE;
if(data->set.proxyauth && data->state.authproxy.avail) {
/* proxy auth was requested and there was proxy auth available,
then deem this as "mere" proxy disconnect */
conn->bits.proxy_connect_closed = TRUE;
}
else {
error = SELECT_ERROR;
failf(data, "Proxy CONNECT aborted");
}
}
else {
/*
* We got a whole chunk of data, which can be anything from one
* byte to a set of lines and possibly just a piece of the last
* line.
*/
int i;
nread += gotbytes;
if(keepon > TRUE) {
/* This means we are currently ignoring a response-body */
nread = 0; /* make next read start over in the read buffer */
ptr=data->state.buffer;
if(cl) {
/* A Content-Length based body: simply count down the counter
and make sure to break out of the loop when we're done! */
cl -= gotbytes;
if(cl<=0) {
keepon = FALSE;
break;
}
}
else {
/* chunked-encoded body, so we need to do the chunked dance
properly to know when the end of the body is reached */
CHUNKcode r;
ssize_t tookcareof=0;
/* now parse the chunked piece of data so that we can
properly tell when the stream ends */
r = Curl_httpchunk_read(conn, ptr, gotbytes, &tookcareof);
if(r == CHUNKE_STOP) {
/* we're done reading chunks! */
infof(data, "chunk reading DONE\n");
keepon = FALSE;
/* we did the full CONNECT treatment, go COMPLETE */
conn->tunnel_state[sockindex] = TUNNEL_COMPLETE;
}
else
infof(data, "Read %zd bytes of chunk, continue\n",
tookcareof);
}
}
else
for(i = 0; i < gotbytes; ptr++, i++) {
perline++; /* amount of bytes in this line so far */
if(*ptr == 0x0a) {
char letter;
int writetype;
/* convert from the network encoding */
result = Curl_convert_from_network(data, line_start,
perline);
/* Curl_convert_from_network calls failf if unsuccessful */
if(result)
return result;
/* output debug if that is requested */
if(data->set.verbose)
Curl_debug(data, CURLINFO_HEADER_IN,
line_start, (size_t)perline, conn);
/* send the header to the callback */
writetype = CLIENTWRITE_HEADER;
if(data->set.include_header)
writetype |= CLIENTWRITE_BODY;
result = Curl_client_write(conn, writetype, line_start,
perline);
data->info.header_size += (long)perline;
data->req.headerbytecount += (long)perline;
if(result)
return result;
/* Newlines are CRLF, so the CR is ignored as the line isn't
really terminated until the LF comes. Treat a following CR
as end-of-headers as well.*/
if(('\r' == line_start[0]) ||
('\n' == line_start[0])) {
/* end of response-headers from the proxy */
nread = 0; /* make next read start over in the read
buffer */
ptr=data->state.buffer;
if((407 == k->httpcode) && !data->state.authproblem) {
/* If we get a 407 response code with content length
when we have no auth problem, we must ignore the
whole response-body */
keepon = 2;
if(cl) {
infof(data, "Ignore %" FORMAT_OFF_T
" bytes of response-body\n", cl);
/* remove the remaining chunk of what we already
read */
cl -= (gotbytes - i);
if(cl<=0)
/* if the whole thing was already read, we are done!
*/
keepon=FALSE;
}
else if(chunked_encoding) {
CHUNKcode r;
/* We set ignorebody true here since the chunked
decoder function will acknowledge that. Pay
attention so that this is cleared again when this
function returns! */
k->ignorebody = TRUE;
infof(data, "%zd bytes of chunk left\n", gotbytes-i);
if(line_start[1] == '\n') {
/* this can only be a LF if the letter at index 0
was a CR */
line_start++;
i++;
}
/* now parse the chunked piece of data so that we can
properly tell when the stream ends */
r = Curl_httpchunk_read(conn, line_start+1,
gotbytes -i, &gotbytes);
if(r == CHUNKE_STOP) {
/* we're done reading chunks! */
infof(data, "chunk reading DONE\n");
keepon = FALSE;
/* we did the full CONNECT treatment, go to
COMPLETE */
conn->tunnel_state[sockindex] = TUNNEL_COMPLETE;
}
else
infof(data, "Read %zd bytes of chunk, continue\n",
gotbytes);
}
else {
/* without content-length or chunked encoding, we
can't keep the connection alive since the close is
the end signal so we bail out at once instead */
keepon=FALSE;
}
}
else {
keepon = FALSE;
if(200 == data->info.httpproxycode) {
if(gotbytes - (i+1))
failf(data, "Proxy CONNECT followed by %zd bytes "
"of opaque data. Data ignored (known bug #39)",
gotbytes - (i+1));
}
}
/* we did the full CONNECT treatment, go to COMPLETE */
conn->tunnel_state[sockindex] = TUNNEL_COMPLETE;
break; /* breaks out of for-loop, not switch() */
}
/* keep a backup of the position we are about to blank */
letter = line_start[perline];
line_start[perline]=0; /* zero terminate the buffer */
if((checkprefix("WWW-Authenticate:", line_start) &&
(401 == k->httpcode)) ||
(checkprefix("Proxy-authenticate:", line_start) &&
(407 == k->httpcode))) {
result = Curl_http_input_auth(conn, k->httpcode,
line_start);
if(result)
return result;
}
else if(checkprefix("Content-Length:", line_start)) {
cl = curlx_strtoofft(line_start +
strlen("Content-Length:"), NULL, 10);
}
else if(Curl_compareheader(line_start,
"Connection:", "close"))
closeConnection = TRUE;
else if(Curl_compareheader(line_start,
"Transfer-Encoding:",
"chunked")) {
infof(data, "CONNECT responded chunked\n");
chunked_encoding = TRUE;
/* init our chunky engine */
Curl_httpchunk_init(conn);
}
else if(Curl_compareheader(line_start,
"Proxy-Connection:", "close"))
closeConnection = TRUE;
else if(2 == sscanf(line_start, "HTTP/1.%d %d",
&subversion,
&k->httpcode)) {
/* store the HTTP code from the proxy */
data->info.httpproxycode = k->httpcode;
}
/* put back the letter we blanked out before */
line_start[perline]= letter;
perline=0; /* line starts over here */
line_start = ptr+1; /* this skips the zero byte we wrote */
}
}
}
break;
} /* switch */
if(Curl_pgrsUpdate(conn))
return CURLE_ABORTED_BY_CALLBACK;
} /* while there's buffer left and loop is requested */
if(error)
return CURLE_RECV_ERROR;
if(data->info.httpproxycode != 200) {
/* Deal with the possibly already received authenticate
headers. 'newurl' is set to a new URL if we must loop. */
result = Curl_http_auth_act(conn);
if(result)
return result;
if(conn->bits.close)
/* the connection has been marked for closure, most likely in the
Curl_http_auth_act() function and thus we can kill it at once
below
*/
closeConnection = TRUE;
}
if(closeConnection && data->req.newurl) {
/* Connection closed by server. Don't use it anymore */
Curl_closesocket(conn, conn->sock[sockindex]);
conn->sock[sockindex] = CURL_SOCKET_BAD;
break;
}
} /* END NEGOTIATION PHASE */
/* If we are supposed to continue and request a new URL, which basically
* means the HTTP authentication is still going on so if the tunnel
* is complete we start over in INIT state */
if(data->req.newurl &&
(TUNNEL_COMPLETE == conn->tunnel_state[sockindex])) {
conn->tunnel_state[sockindex] = TUNNEL_INIT;
infof(data, "TUNNEL_STATE switched to: %d\n",
conn->tunnel_state[sockindex]);
}
} while(data->req.newurl);
if(200 != data->req.httpcode) {
failf(data, "Received HTTP code %d from proxy after CONNECT",
data->req.httpcode);
if(closeConnection && data->req.newurl)
conn->bits.proxy_connect_closed = TRUE;
if(data->req.newurl) {
/* this won't be used anymore for the CONNECT so free it now */
free(data->req.newurl);
data->req.newurl = NULL;
}
/* to back to init state */
conn->tunnel_state[sockindex] = TUNNEL_INIT;
return CURLE_RECV_ERROR;
}
conn->tunnel_state[sockindex] = TUNNEL_COMPLETE;
/* If a proxy-authorization header was used for the proxy, then we should
make sure that it isn't accidentally used for the document request
after we've connected. So let's free and clear it here. */
Curl_safefree(conn->allocptr.proxyuserpwd);
conn->allocptr.proxyuserpwd = NULL;
data->state.authproxy.done = TRUE;
infof (data, "Proxy replied OK to CONNECT request\n");
data->req.ignorebody = FALSE; /* put it (back) to non-ignore state */
conn->bits.rewindaftersend = FALSE; /* make sure this isn't set for the
document request */
return CURLE_OK;
}
