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; }