STSStatus request_perform(RequestParams* params, int* httpResponseCode, char* response)
{
Request* request = 0;
STSStatus status;
if (STSStatusOK != (status = request_get(params, &request))) {
fprintf(stderr, "Request Get ERR\n");
return status;
}
request->getResultCallback = responseCallback;
request->callbackData = response;
request->status = STSStatusWaiting;
CURLcode code = curl_easy_perform(request->curl);
if (CURLE_OK != code) {
request->httpResponseCode = 0;
*httpResponseCode = request->httpResponseCode;
request->status = request_curl_code_to_status(code);
return request->status;
}
else {
*httpResponseCode = request->httpResponseCode;
request_finish(request);
return request->status;
}
}
void Audex::start() {
emit changedEncodeTrack(0, 0, "");
emit info(i18n("Start ripping and encoding with profile \"%1\"...", p_profile_name));
if (check()) start_extract(); else request_finish(FALSE);
}
int udp_request_process (Context *cont) {
char *fn = "udp_request_process()";
struct sockaddr *sa;
syslog (LOG_DEBUG, "%s: start", fn);
/*
* ev_udp_in() called us to process an incoming response
* to the request we sent. The response message has been
* put in cont->mesg.p
*/
/*
* Timeout will still go off later, so we render
* it harmless here by removing the handler.
*/
if (cont->tout)
cont->tout->handler = NULL;
/* remove me from I/O list */
sa = (struct sockaddr *) cont->current_ns->list_data;
if (ev_udp_in_remove (sa, cont->q_id) < 0)
return (request_abort (cont, -1));
else
return request_finish (cont);
}
S3Status S3_finish_request_context(S3RequestContext *requestContext)
{
CURLMsg *msg;
int junk;
while ((msg = curl_multi_info_read(requestContext->curlm, &junk))) {
if (msg->msg != CURLMSG_DONE) {
return S3StatusInternalError;
}
Request *request;
if (curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
(char **) (char *) &request) != CURLE_OK) {
return S3StatusInternalError;
}
// Remove the request from the list of requests
if (request->prev == request->next) {
// It was the only one on the list
requestContext->requests = 0;
}
else {
// It doesn't matter what the order of them are, so just in
// case request was at the head of the list, put the one after
// request to the head of the list
requestContext->requests = request->next;
request->prev->next = request->next;
request->next->prev = request->prev;
}
if ((msg->data.result != CURLE_OK) &&
(request->status == S3StatusOK)) {
request->status = request_curl_code_to_status
(msg->data.result);
if (! request->errorParser.s3ErrorDetails.message) {
request->errorParser.s3ErrorDetails.message =
curl_easy_strerror(msg->data.result);
}
}
if (curl_multi_remove_handle(requestContext->curlm,
msg->easy_handle) != CURLM_OK) {
return S3StatusInternalError;
}
// Finish the request, ensuring that all callbacks have been made,
// and also releases the request
request_finish(request);
// Now, since a callback was made, there may be new requests
// queued up to be performed immediately, so do so
}
return S3StatusOK;
}
void S3_destroy_request_context(S3RequestContext *requestContext)
{
curl_multi_cleanup(requestContext->curlm);
// For each request in the context, call back its done method with
// 'interrupted' status
Request *r = requestContext->requests, *rFirst = r;
if (r) do {
r->status = S3StatusInterrupted;
Request *rNext = r->next;
request_finish(r);
r = rNext;
} while (r != rFirst);
free(requestContext);
}
void request_perform(const RequestParams *params, S3RequestContext *context)
{
Request *request;
S3Status status;
#define return_status(status) \
(*(params->completeCallback))(status, 0, params->callbackData); \
return
// These will hold the computed values
RequestComputedValues computed;
// Validate the bucket name
if (params->bucketContext.bucketName &&
((status = S3_validate_bucket_name
(params->bucketContext.bucketName,
params->bucketContext.uriStyle)) != S3StatusOK)) {
return_status(status);
}
// Compose the amz headers
if ((status = compose_amz_headers(params, &computed)) != S3StatusOK) {
return_status(status);
}
// Compose standard headers
if ((status = compose_standard_headers
(params, &computed)) != S3StatusOK) {
return_status(status);
}
// URL encode the key
if ((status = encode_key(params, &computed)) != S3StatusOK) {
return_status(status);
}
// Compute the canonicalized amz headers
canonicalize_amz_headers(&computed);
// Compute the canonicalized resource
canonicalize_resource(params->bucketContext.bucketName,
params->subResource, computed.urlEncodedKey,
computed.canonicalizedResource);
// Compose Authorization header
if ((status = compose_auth_header(params, &computed)) != S3StatusOK) {
return_status(status);
}
// Get an initialized Request structure now
if ((status = request_get(params, &computed, &request)) != S3StatusOK) {
return_status(status);
}
// If a RequestContext was provided, add the request to the curl multi
if (context) {
CURLMcode code = curl_multi_add_handle(context->curlm, request->curl);
if (code == CURLM_OK) {
if (context->requests) {
request->prev = context->requests->prev;
request->next = context->requests;
context->requests->prev->next = request;
context->requests->prev = request;
}
else {
context->requests = request->next = request->prev = request;
}
}
else {
if (request->status == S3StatusOK) {
request->status = (code == CURLM_OUT_OF_MEMORY) ?
S3StatusOutOfMemory : S3StatusInternalError;
}
request_finish(request);
}
}
// Else, perform the request immediately
else {
CURLcode code = curl_easy_perform(request->curl);
if ((code != CURLE_OK) && (request->status == S3StatusOK)) {
request->status = request_curl_code_to_status(code);
}
// Finish the request, ensuring that all callbacks have been made, and
// also releases the request
request_finish(request);
}
}
void Audex::slot_error(const QString& description, const QString& solution) {
emit error(description, solution);
request_finish(FALSE);
}
void Audex::start_encode() {
if (_finished) return;
if (p_single_file) {
if (en_track_count >= 1) {
request_finish(TRUE);
return;
}
if (encoder_wrapper->isProcessing()) return;
AudexJob* job = jobs->orderJob();
if (!job) return;
int cdnum = cdda_model->cdNum();
int nooftracks = cdda_model->numOfAudioTracks();
QString artist = cdda_model->artist();
QString title = cdda_model->title();
QString year = cdda_model->year();
QString genre = cdda_model->genre();
QString suffix = p_suffix;
CachedImage *cover = cdda_model->cover();
QString targetFilename = job->targetFilename();
en_track_target_filename = targetFilename;
emit changedEncodeTrack(job->trackNo(), 1, targetFilename);
en_track_count++;
en_track_filename = job->sourceFilename();
en_track_index = job->trackNo();
if (!encoder_wrapper->encode(job->trackNo(), cdnum, 0, nooftracks,
artist, title, artist, title, genre, year, suffix, cover, FALSE, tmp_path,
job->sourceFilename(), targetFilename)) {
request_finish(FALSE);
}
process_counter++;
} else {
if (en_track_count >= cdda_model->numOfAudioTracksInSelection()) {
request_finish(TRUE);
return;
}
if (encoder_wrapper->isProcessing()) return;
AudexJob* job = jobs->orderJob();
if (!job) return;
int cdnum = cdda_model->cdNum();
int trackoffset = cdda_model->trackOffset();
int nooftracks = cdda_model->numOfAudioTracks();
QString artist = cdda_model->artist();
QString title = cdda_model->title();
QString tartist = cdda_model->data(cdda_model->index(job->trackNo()-1, CDDA_MODEL_COLUMN_ARTIST_INDEX)).toString();
QString ttitle = cdda_model->data(cdda_model->index(job->trackNo()-1, CDDA_MODEL_COLUMN_TITLE_INDEX)).toString();
QString year = cdda_model->year();
QString genre = cdda_model->genre();
QString suffix = p_suffix;
CachedImage *cover = cdda_model->cover();
bool fat32_compatible = profile_model->data(profile_model->index(profile_model->currentProfileRow(), PROFILE_MODEL_COLUMN_FAT32COMPATIBLE_INDEX)).toBool();
QString targetFilename = job->targetFilename();
en_track_target_filename = targetFilename;
emit changedEncodeTrack(job->trackNo(), cdda_model->numOfAudioTracks(), targetFilename);
en_track_count++;
en_track_filename = job->sourceFilename();
en_track_index = job->trackNo();
if (cdda_model->isVarious()) {
if (!encoder_wrapper->encode(job->trackNo(), cdnum, trackoffset, nooftracks,
artist, title, tartist, ttitle, genre, year, suffix, cover, fat32_compatible, tmp_path,
job->sourceFilename(), targetFilename)) {
request_finish(FALSE);
}
} else {
if (!encoder_wrapper->encode(job->trackNo(), cdnum, trackoffset, nooftracks,
artist, title, artist, ttitle, genre, year, suffix, cover, fat32_compatible, tmp_path,
job->sourceFilename(), targetFilename)) {
request_finish(FALSE);
}
}
process_counter++;
}
}
void Audex::start_extract() {
if (_finished) return;
if (p_single_file) {
if (ex_track_count >= 1) {
if (!jobs->jobInProgress() && !jobs->pendingJobs()) request_finish(TRUE);
return;
}
ex_track_index++;
QString artist = cdda_model->artist();
QString title = cdda_model->title();
QString year = cdda_model->year();
QString genre = cdda_model->genre();
QString suffix = p_suffix;
QString basepath = Preferences::basePath();
int cdnum;
if (!cdda_model->isMultiCD()) cdnum = 0; else cdnum = cdda_model->cdNum();
int nooftracks = cdda_model->numOfAudioTracks();
bool overwrite = Preferences::overwriteExistingFiles();
QString targetFilename;
if (!construct_target_filename_for_singlefile(targetFilename, cdnum, nooftracks, artist, title, year, genre, suffix, basepath, overwrite)) {
request_finish(FALSE);
return;
}
ex_track_target_filename = targetFilename;
cdda_model->setCustomData("filename", targetFilename);
//if empty (maybe because it already exists) skip
if (!targetFilename.isEmpty()) {
emit changedExtractTrack(ex_track_index,
1,
artist,
title);
QString sourceFilename = tmp_path+QString("%1").arg(DiscIDCalculator::FreeDBId(cdda_model->discSignature()))+".wav";
ex_track_source_filename = sourceFilename;
wave_file_writer->open(sourceFilename);
if (Preferences::paranoiaMode()) {
cdda_extract_thread->setParanoiaMode(3);
} else {
cdda_extract_thread->setParanoiaMode(0);
}
cdda_extract_thread->setNeverSkip(Preferences::neverSkip());
cdda_extract_thread->setTrackToRip(0);
cdda_extract_thread->start(); process_counter++;
ex_track_count++;
} else {
if (!jobs->jobInProgress() && !jobs->pendingJobs()) request_finish(TRUE);
}
} else {
if (ex_track_count >= cdda_model->numOfAudioTracksInSelection()) {
if (!jobs->jobInProgress() && !jobs->pendingJobs()) request_finish(TRUE);
return;
}
ex_track_index++;
bool skip = !cdda_model->isTrackInSelection(ex_track_index);
if (!cdda_model->isAudioTrack(ex_track_index)) skip = TRUE;
if (!skip) {
QString artist = cdda_model->artist();
QString title = cdda_model->title();
QString tartist = cdda_model->data(cdda_model->index(ex_track_index-1, CDDA_MODEL_COLUMN_ARTIST_INDEX)).toString();
QString ttitle = cdda_model->data(cdda_model->index(ex_track_index-1, CDDA_MODEL_COLUMN_TITLE_INDEX)).toString();
QString year = cdda_model->year();
QString genre = cdda_model->genre();
QString suffix = p_suffix;
QString basepath = Preferences::basePath();
bool fat32_compatible = profile_model->data(profile_model->index(profile_model->currentProfileRow(), PROFILE_MODEL_COLUMN_FAT32COMPATIBLE_INDEX)).toBool();
bool replacespaceswithunderscores = profile_model->data(profile_model->index(profile_model->currentProfileRow(), PROFILE_MODEL_COLUMN_UNDERSCORE_INDEX)).toBool();
bool _2digitstracknum = profile_model->data(profile_model->index(profile_model->currentProfileRow(), PROFILE_MODEL_COLUMN_2DIGITSTRACKNUM_INDEX)).toBool();
int cdnum;
if (!cdda_model->isMultiCD()) cdnum = 0; else cdnum = cdda_model->cdNum();
int trackoffset = cdda_model->trackOffset();
int nooftracks = cdda_model->numOfAudioTracks();
bool overwrite = Preferences::overwriteExistingFiles();
QString targetFilename;
if (cdda_model->isVarious()) {
if (!construct_target_filename(targetFilename, ex_track_index, cdnum, nooftracks, trackoffset,
artist, title, tartist, ttitle, year, genre, suffix, basepath, fat32_compatible, replacespaceswithunderscores, _2digitstracknum, overwrite, (ex_track_index==1))) {
request_finish(FALSE);
return;
}
} else {
if (!construct_target_filename(targetFilename, ex_track_index, cdnum, nooftracks, trackoffset,
artist, title, artist, ttitle, year, genre, suffix, basepath, fat32_compatible, replacespaceswithunderscores, _2digitstracknum, overwrite, (ex_track_index==1))) {
request_finish(FALSE);
return;
}
}
ex_track_target_filename = targetFilename;
//if empty (maybe because it already exists) skip
if (!targetFilename.isEmpty()) {
emit changedExtractTrack(ex_track_index,
cdda_model->numOfAudioTracks(),
tartist,
ttitle);
QString sourceFilename = tmp_path+QString("%1").arg(DiscIDCalculator::FreeDBId(cdda_model->discSignature()))+"."+QString("%1").arg(ex_track_index)+".wav";
ex_track_source_filename = sourceFilename;
wave_file_writer->open(sourceFilename);
if (Preferences::paranoiaMode()) {
cdda_extract_thread->setParanoiaMode(3);
} else {
cdda_extract_thread->setParanoiaMode(0);
}
cdda_extract_thread->setNeverSkip(Preferences::neverSkip());
cdda_extract_thread->setTrackToRip(ex_track_index);
cdda_extract_thread->start(); process_counter++;
ex_track_count++;
} else {
en_track_count++;
ex_track_count++; //important to check for finish
cdda_extract_thread->skipTrack(ex_track_index);
start_extract();
}
} else {
start_extract();
}
}
}
void Audex::cancel() {
request_finish(FALSE);
}
S3Status S3_runonce_request_context(S3RequestContext *requestContext,
int *requestsRemainingReturn)
{
CURLMcode status;
do {
status = curl_multi_perform(requestContext->curlm,
requestsRemainingReturn);
switch (status) {
case CURLM_OK:
case CURLM_CALL_MULTI_PERFORM:
break;
case CURLM_OUT_OF_MEMORY:
return S3StatusOutOfMemory;
default:
return S3StatusInternalError;
}
CURLMsg *msg;
int junk;
while ((msg = curl_multi_info_read(requestContext->curlm, &junk))) {
if (msg->msg != CURLMSG_DONE) {
return S3StatusInternalError;
}
Request *request;
if (curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE,
(char **) (char *) &request) != CURLE_OK) {
return S3StatusInternalError;
}
// Remove the request from the list of requests
if (request->prev == request->next) {
// It was the only one on the list
requestContext->requests = 0;
}
else {
// It doesn't matter what the order of them are, so just in
// case request was at the head of the list, put the one after
// request to the head of the list
requestContext->requests = request->next;
request->prev->next = request->next;
request->next->prev = request->prev;
}
if ((msg->data.result != CURLE_OK) &&
(request->status == S3StatusOK)) {
request->status = request_curl_code_to_status
(msg->data.result);
}
if (curl_multi_remove_handle(requestContext->curlm,
msg->easy_handle) != CURLM_OK) {
return S3StatusInternalError;
}
// Finish the request, ensuring that all callbacks have been made,
// and also releases the request
request_finish(request);
// Now, since a callback was made, there may be new requests
// queued up to be performed immediately, so do so
status = CURLM_CALL_MULTI_PERFORM;
}
} while (status == CURLM_CALL_MULTI_PERFORM);
return S3StatusOK;
}
