void SocketReply::handle(EventHandler &handler)
{
size_t to_write = data.size() - ptr;
ssize_t ret = write(fd, data.data() + ptr, to_write);
if (ret <= 0)
{
handler.remove(*this);
end_cb(false);
}
else
ptr += ret;
if (ptr >= data.size())
{
handler.remove(*this);
end_cb(true);
}
}
void load_block(struct game_state *gs)
{
enum shape_t all_shapes[] = { SHAPE_BOX, SHAPE_LOW,
SHAPE_MID, SHAPE_TOP, SHAPE_LEF, SHAPE_RIG,
SHAPE_BAR };
int k = sizeof(all_shapes) / sizeof(all_shapes[0]);
gs->shape = all_shapes[rand()%k];
gs->y = 0;
if (!fit_block(gs)) {
end_cb(gs);
}
put_shape(gs, 4);
}
static void key_cb(SDL_Keycode k, int shift, struct game_state *gs)
{
switch (k)
{
case SDLK_r: init_game_state(gs); break;
case SDLK_q: if (shift) end_cb(gs); break;
case SDLK_j:
case SDLK_s: drop_block(gs); break;
case SDLK_h:
case SDLK_a: move_x(gs, -1); break;
case SDLK_l:
case SDLK_d: move_x(gs, 1); break;
case SDLK_k:
case SDLK_w: rot_block(gs); break;
}
draw_cb(gs);
}
int main(int argc, char **argv)
{
struct game_state *gs = init_window(125000);
SDL_Event ev;
int mods;
draw_cb(gs);
while (1) {
SDL_RenderPresent(gs->surface);
SDL_WaitEvent(&ev);
switch (ev.type) {
case SDL_QUIT:
end_cb(gs);
break;
case SDL_KEYDOWN:
mods = SDL_GetModState();
key_cb(ev.key.keysym.sym, mods & KMOD_SHIFT, gs);
break;
}
}
return 0;
}
void
event_cb(Esql_Res *res, Zentific_Ctx *ctx){
const char *query;
Z_Ctx_Cb end_cb;
Zrpcdb_Cb cb;
Esql_Query_Id qid;
long long int insert_id;
DB *db;
Eina_Bool state;
qid = esql_res_query_id_get(res);
state = ctx->state;
ctx->state = EINA_FALSE;
if (esql_res_error_get(res)){
ERR("Query %lu: \"%s\" - %s", qid, esql_res_query_get(res), esql_res_error_get(res));
eina_hash_del_by_key(db_cbs, &qid);
ctx->error = AZY_ERR(DB_QUERY);
ecore_event_add(ZRPCDB_EVENT_ERROR, ctx, fake_free, NULL);
return;
}
query = esql_res_query_get(res);
cb = eina_hash_find(type_cbs, &qid);
db = esql_data_get(esql_res_esql_get(res));
if (cb) { /* all SELECT calls have cbs */
DBG("%i rows returned", esql_res_rows_count(res));
if (state && (esql_res_rows_count(res) > 1)){
ctx->error = AZY_ERR(DB_MULTI);
eina_hash_del_by_key(db_cbs, &qid);
ctx->state = state;
ecore_event_add(ZRPCDB_EVENT_ERROR, ctx, fake_free, NULL);
return;
}
end_cb = eina_hash_find(db_cbs, &qid); /* another db call queued */
if (end_cb) {
eina_hash_del_by_key(db_cbs, &qid);
end_cb(res, ctx, cb(res));
return;
}
if (ctx->cbs){
end_cb = ctx->cbs->data;
end_cb(ctx, cb(res));
} else {
ctx->state = state;
ctx->retval = cb(res);
ecore_event_add(ZRPCDB_EVENT_RESULT, ctx, fake_free, NULL);
}
return;
}
end_cb = eina_hash_find(db_cbs, &qid); /* another db call queued */
insert_id = esql_res_id(res);
if (esql_res_rows_affected(res))
INF("Query \"%s\" inserted with id %lli", esql_res_query_get(res), insert_id);
else
ERR("Query \"%s\" affected 0 rows", esql_res_query_get(res));
if (end_cb) {
eina_hash_del_by_key(db_cbs, &qid);
if (state) end_cb(res, ctx, insert_id);
else end_cb(res, ctx);
return;
}
if (ctx->cbs) {
end_cb = ctx->cbs->data;
if (state) end_cb(ctx, insert_id);
else end_cb(ctx);
} else {
ctx->state = state;
ctx->retval = (intptr_t*)(int)insert_id;
ecore_event_add(ZRPCDB_EVENT_RESULT, ctx, fake_free, NULL);
}
}
gboolean
lr_download_packages(GSList *targets,
LrPackageDownloadFlag flags,
GError **err)
{
gboolean ret;
gboolean failfast = flags & LR_PACKAGEDOWNLOAD_FAILFAST;
struct sigaction old_sigact;
GSList *downloadtargets = NULL;
gboolean interruptible = FALSE;
assert(!err || *err == NULL);
if (!targets)
return TRUE;
// Check targets
for (GSList *elem = targets; elem; elem = g_slist_next(elem)) {
LrPackageTarget *packagetarget = elem->data;
if (!packagetarget->handle) {
continue;
/*
g_set_error(err, LR_PACKAGE_DOWNLOADER_ERROR, LRE_BADFUNCARG,
"Package target %s doesn't have specified a handle",
packagetarget->relative_url);
return FALSE;
*/
}
if (packagetarget->handle->interruptible)
interruptible = TRUE;
// Check repotype
// Note: Checked because lr_handle_prepare_internal_mirrorlist
// support only LR_YUMREPO yet
if (packagetarget->handle->repotype != LR_YUMREPO) {
g_debug("%s: Bad repo type", __func__);
g_set_error(err, LR_PACKAGE_DOWNLOADER_ERROR, LRE_BADFUNCARG,
"Bad repo type");
return FALSE;
}
}
// Setup sighandler
if (interruptible) {
struct sigaction sigact;
g_debug("%s: Using own SIGINT handler", __func__);
memset(&sigact, 0, sizeof(old_sigact));
memset(&sigact, 0, sizeof(sigact));
sigemptyset(&sigact.sa_mask);
sigact.sa_handler = lr_sigint_handler;
sigaddset(&sigact.sa_mask, SIGINT);
sigact.sa_flags = SA_RESTART;
if (sigaction(SIGINT, &sigact, &old_sigact) == -1) {
g_set_error(err, LR_PACKAGE_DOWNLOADER_ERROR, LRE_SIGACTION,
"Cannot set Librepo SIGINT handler");
return FALSE;
}
}
// List of handles for fastest mirror resolving
GSList *fmr_handles = NULL;
// Prepare targets
for (GSList *elem = targets; elem; elem = g_slist_next(elem)) {
gchar *local_path;
LrPackageTarget *packagetarget = elem->data;
LrDownloadTarget *downloadtarget;
gint64 realsize = -1;
gboolean doresume = packagetarget->resume;
// Reset output attributes of the handle
lr_packagetarget_reset(packagetarget);
// Prepare destination filename
if (packagetarget->dest) {
if (g_file_test(packagetarget->dest, G_FILE_TEST_IS_DIR)) {
// Dir specified
gchar *file_basename = g_path_get_basename(packagetarget->relative_url);
local_path = g_build_filename(packagetarget->dest,
file_basename,
NULL);
g_free(file_basename);
} else {
local_path = g_strdup(packagetarget->dest);
}
} else {
// No destination path specified
local_path = g_path_get_basename(packagetarget->relative_url);
}
packagetarget->local_path = g_string_chunk_insert(packagetarget->chunk,
local_path);
g_free(local_path);
// Check expected size and real size if the file exists
if (doresume
&& g_access(packagetarget->local_path, R_OK) == 0
&& packagetarget->expectedsize > 0)
{
struct stat buf;
if (stat(packagetarget->local_path, &buf)) {
g_set_error(err, LR_PACKAGE_DOWNLOADER_ERROR, LRE_IO,
"Cannot stat %s: %s", packagetarget->local_path,
g_strerror(errno));
return FALSE;
}
realsize = buf.st_size;
if (packagetarget->expectedsize < realsize)
// Existing file is bigger then the one that is expected,
// disable resuming
doresume = FALSE;
}
if (g_access(packagetarget->local_path, R_OK) == 0
&& packagetarget->checksum
&& packagetarget->checksum_type != LR_CHECKSUM_UNKNOWN)
{
/* If the file exists and checksum is ok, then is pointless to
* download the file again.
* Moreover, if the resume is enabled and the file is already
* completely downloaded, then the download is going to fail.
*/
int fd_r = open(packagetarget->local_path, O_RDONLY);
if (fd_r != -1) {
gboolean matches;
ret = lr_checksum_fd_cmp(packagetarget->checksum_type,
fd_r,
packagetarget->checksum,
1,
&matches,
NULL);
close(fd_r);
if (ret && matches) {
// Checksum calculation was ok and checksum matches
g_debug("%s: Package %s is already downloaded (checksum matches)",
__func__, packagetarget->local_path);
packagetarget->err = g_string_chunk_insert(
packagetarget->chunk,
"Already downloaded");
// Call end callback
LrEndCb end_cb = packagetarget->endcb;
if (end_cb)
end_cb(packagetarget->cbdata,
LR_TRANSFER_ALREADYEXISTS,
"Already downloaded");
continue;
} else if (ret) {
// Checksum calculation was ok but checksum doesn't match
if (realsize != -1 && realsize == packagetarget->expectedsize)
// File size is the same as the expected one
// Don't try to resume
doresume = FALSE;
}
}
}
if (doresume && realsize != -1 && realsize == packagetarget->expectedsize) {
// File's size matches the expected one, the resume is enabled and
// no checksum is known => expect that the file is
// the one the user wants
g_debug("%s: Package %s is already downloaded (size matches)",
__func__, packagetarget->local_path);
packagetarget->err = g_string_chunk_insert(
packagetarget->chunk,
"Already downloaded");
// Call end callback
LrEndCb end_cb = packagetarget->endcb;
if (end_cb)
end_cb(packagetarget->cbdata,
LR_TRANSFER_ALREADYEXISTS,
"Already downloaded");
continue;
}
if (packagetarget->handle) {
ret = lr_handle_prepare_internal_mirrorlist(packagetarget->handle,
FALSE,
err);
if (!ret)
goto cleanup;
if (packagetarget->handle->fastestmirror) {
if (!g_slist_find(fmr_handles, packagetarget->handle))
fmr_handles = g_slist_prepend(fmr_handles,
packagetarget->handle);
}
}
GSList *checksums = NULL;
LrDownloadTargetChecksum *checksum;
checksum = lr_downloadtargetchecksum_new(packagetarget->checksum_type,
packagetarget->checksum);
checksums = g_slist_prepend(checksums, checksum);
downloadtarget = lr_downloadtarget_new(packagetarget->handle,
packagetarget->relative_url,
packagetarget->base_url,
-1,
packagetarget->local_path,
checksums,
packagetarget->expectedsize,
doresume,
packagetarget->progresscb,
packagetarget->cbdata,
packagetarget->endcb,
packagetarget->mirrorfailurecb,
packagetarget,
packagetarget->byterangestart,
packagetarget->byterangeend);
downloadtargets = g_slist_append(downloadtargets, downloadtarget);
}
// Do Fastest Mirror resolving for all handles in one shot
if (fmr_handles) {
fmr_handles = g_slist_reverse(fmr_handles);
ret = lr_fastestmirror_sort_internalmirrorlists(fmr_handles, err);
g_slist_free(fmr_handles);
if (!ret) {
return FALSE;
}
}
// Start downloading
ret = lr_download(downloadtargets, failfast, err);
cleanup:
// Copy download statuses from downloadtargets to targets
for (GSList *elem = downloadtargets; elem; elem = g_slist_next(elem)) {
LrDownloadTarget *downloadtarget = elem->data;
LrPackageTarget *packagetarget = downloadtarget->userdata;
if (downloadtarget->err)
packagetarget->err = g_string_chunk_insert(packagetarget->chunk,
downloadtarget->err);
}
// Free downloadtargets list
g_slist_free_full(downloadtargets, (GDestroyNotify)lr_downloadtarget_free);
// Restore original signal handler
if (interruptible) {
g_debug("%s: Restoring an old SIGINT handler", __func__);
sigaction(SIGINT, &old_sigact, NULL);
if (lr_interrupt) {
if (err && *err != NULL)
g_clear_error(err);
g_set_error(err, LR_PACKAGE_DOWNLOADER_ERROR, LRE_INTERRUPTED,
"Insterupted by a SIGINT signal");
return FALSE;
}
}
return ret;
}
