char* disk_left(char * output, char * path){ struct statvfs buf; if (!statvfs(path, &buf)) { unsigned long long free; free = (long long)buf.f_bsize * (long long)buf.f_bavail; readable_fs((double)free, output); } return output; }
// ==================================================================================================== // Main // ==================================================================================================== int main(int argc, const char* argv[]) { /* * Delete old updater */ if (file_exists("updater_old.exe")) { DeleteFile("updater_old.exe"); } // Download UpdateInfo.ini printf("Searching for updates..\n"); DownloadThreadInfo* pUpdateInfo = DownloadFile("http://hive-mind.eu/fastdl/data/freschi/UpdateInfo.ini", "UpdateInfo.ini"); while (!pUpdateInfo->bFinished) { Sleep(50); } // Read UpdateInfo.ini // Read: Latest Version Number std::string _s_latest_rev = CIniFile::GetValue("VersionNumber", "Latest", "UpdateInfo.ini"); int latest_rev; try { latest_rev = std::stoi(_s_latest_rev); } catch (...) { printf("Failed to parse UpdateInfo.ini\n"); getchar(); return 0; } std::string latest_rev_name = CIniFile::GetValue("VersionName", "Latest", "UpdateInfo.ini"); printf("Latest Version: %s (Revision Number: %i)\n", latest_rev_name.c_str(), latest_rev); // Current Version int client_rev; std::string client_rev_s; try { client_rev_s = CIniFile::GetValue("VersionName", "Current", "Updater.ini"); client_rev = std::stoi(CIniFile::GetValue("VersionNumber", "Current", "Updater.ini")); } catch (...) { // either update.ini is corrupt or doesnt exist client_rev_s = "[Unknown]"; client_rev = 0; } printf("Installed Version: %s (Revision Number: %i)\n", client_rev_s.c_str(), client_rev); printf("\n\n"); // Redownload everything? bool reinstall_all = false; if (client_rev >= latest_rev) { printf("Client is up-to-date!\n"); printf("Press enter if you wish to reinstall everything...\n"); std::getchar(); reinstall_all = true; } // Check if update is required bool bUpdatedUpdater = false; if (client_rev < latest_rev || reinstall_all) { // Update Required if (!file_exists("Updater.ini")) CIniFile::Create("Updater.ini"); ClearConsole(); // Collect file revisions char buf[48]; sprintf(buf, "Version_r%i", latest_rev); std::vector<CIniFile::Record> files = CIniFile::GetSection(std::string(buf), "UpdateInfo.ini"); for (std::vector<CIniFile::Record>::iterator it = files.begin(); it != files.end(); ++it) { CIniFile::Record rec = *it; // Create directory if (rec.Value == "directory") { CreateDirectory(rec.Key.c_str(), NULL); continue; } // Check File Revision // required and latest ClearConsole(); quick_header_1(latest_rev_name, latest_rev); printf("Checking File %s\n", rec.Key.c_str()); int revision_required = GetFileRevision(rec.Value); int revision_present = GetFileRevision(CIniFile::GetValue(rec.Key, "FileRevisions", "Updater.ini")); // Needs update? if (revision_required > revision_present || reinstall_all || !file_exists(rec.Key)) { char download_url[512]; sprintf(download_url, "http://hive-mind.eu/fastdl/data/freschi/r%i/%s", revision_required, rec.Key.c_str()); std::string saveas = rec.Key; // Utility so Updater can update itself if (saveas == "Updater.exe") { saveas = "updater_new.exe"; bUpdatedUpdater = true; } // Download File DownloadThreadInfo* pUpdateInfo = DownloadFile(std::string(download_url), saveas); while (!pUpdateInfo->bFinished) { ClearConsole(); quick_header_1(latest_rev_name, latest_rev); if (pUpdateInfo->size_total <= 1000) { printf("Downloading %s ...\n", rec.Key.c_str()); } else { printf("Downloading %s (%s/%s)\n\n", rec.Key.c_str(), readable_fs(pUpdateInfo->size_downloaded).c_str(), readable_fs(pUpdateInfo->size_total).c_str()); // Progress Bar printf(" [ "); int ab = 50; // anzahl der balken int pr_re = 100 / ab; // ein balken = pre_re % int pr = (int)pUpdateInfo->progress; for (int i = 0; i < ab; i++) { if (pr >= (i * pr_re)) { printf("="); } else { printf(" "); } } printf(" ] %i %% ", pr); } // short pause Sleep(75); } // Save new File Revision CIniFile::SetValue(rec.Key, rec.Value, "FileRevisions", "Updater.ini"); } } // Done! Change UpdateInfo.ini CIniFile::SetValue("VersionNumber", to_string(latest_rev), "Current", "Updater.ini"); CIniFile::SetValue("VersionName", latest_rev_name, "Current", "Updater.ini"); // Tell user ClearConsole(); printf("Client is up-to-date!\n"); printf("Press enter to quit..\n"); } // Updater-Update if (bUpdatedUpdater) { MoveFile("Updater.exe", "updater_old.exe"); MoveFile("updater_new.exe", "Updater.exe"); } // Done std::getchar(); return 0; }
unsigned int anak_kirim( unsigned int identifikasi, FILE *pberkas, RSA *rsapub, RSA *rsapriv, struct KIRIMBERKAS *kirim, struct INFOALAMAT *infoalamat, int ukuberkas_panjang ){ char pesan[CHUNK_MESSAGE_SIZE]; char pecahan[ENCRYPTED_CONTAINER_SIZE]; size_t panjang_pesan=0; // Perilaku. int status=0;; int maksimal_coba=aturan.tries; int ulang_tunggu=aturan.waitretry; int urut_tunggu=aturan.waitqueue; unsigned int kelompok_kirim=kirim->kelompok_kirim; char *nama_berkas=kirim->berkas; // Identifikasi. bool identifikasi_awal=true; unsigned int identifikasi_sebelumnya=kirim->identifikasi_sebelumnya; // Pengepala Pecahan. int paritas=0; int panji=0; int status_gerbang=0; int status_peladen=0; // Tujuan. char *hostname=kirim->hostname; char *portno=kirim->portno; // Berurutan kirim. kirim->urut_kali++; // Membersihkan isi. memset(pesan, 0, CHUNK_MESSAGE_SIZE); memset(pecahan, 0, MAX_CHUNK_SIZE); // Bila identifikasi // lebih dari MAX_CHUNK_ID, // maka identifikasi adalah NOL. if(identifikasi>MAX_CHUNK_ID){ DEBUG1(_("Telah melebihi maksimal identifikasi %1$i."), MAX_CHUNK_ID); DEBUG1(_("Nilai identifikasi adalah %1$i."), identifikasi); // Ke NOL. identifikasi=0; DEBUG1(_("Mengubah identifikasi ke nilai 0."), 0); // Keluar. DEBUG1(_("Tidak melanjutkan pengiriman."), 0); return identifikasi; }; // Apakah pertama. if(kirim->paksa_panji!=UNDEFINED_FLAG){ // Memaksa panji. panji=kirim->paksa_panji; kirim->paksa_panji=UNDEFINED_FLAG; // Pesan. DEBUG1(_("Memaksa panji '%1$s'."),arti_panji(panji)); // Langsung berhenti bila panji STOP. if(panji==STOP_FLAG){ // Mengirim panji STOP // dan keluar dari perulangan. DEBUG1(_("Menghentikan pengulangan pengiriman."), 0); kirim->do_kirim=false; }; }else if(identifikasi==0){ // Panji. panji=START_FLAG; // Memastikan nama berkas ada. if(!strlen(nama_berkas)){ // Kesalahan. FAIL(_("Gagal memperoleh nama berkas."), 0); exit(EXIT_FAILURE_MEMORY); }; // Pecahan pertama adalah // pecahan dengan informasi berkas. memcpy(pesan, buat_pesan_start( pesan, CHUNK_MESSAGE_SIZE, kirim->berkas_identifikasi, nama_berkas, kirim->ukuran_berkas ), CHUNK_MESSAGE_SIZE); // Apakah hampir akhir. }else if(identifikasi==MAX_CHUNK_ID){ // Panji. DEBUG1(_("Mengirim panji '%1$s'."),_("Henti")); panji=STOP_FLAG; /* }else if (kirim->ukuran_kirim>kirim->ukuran_berkas){ // Panji STOP. DEBUG1(_("Mengirim panji '%1$s'."), _("Henti")); panji=STOP_FLAG; // Hentikan perulangan. // Keluar dari perulangan. DEBUG1(_("Menghentikan pengulangan pengiriman."), 0); kirim->do_kirim=false; */ }else{ // Panji. panji=INTRANSFER_FLAG; // Mendapatkan posisi berkas. long int penunjuk_berkas=0 +((long)(kelompok_kirim-1)*(MAX_CHUNK_ID-1)*CHUNK_MESSAGE_SIZE) +((long)identifikasi-1)*(long)CHUNK_MESSAGE_SIZE; // Bila mendekati dan pecahan transfer terakhir, // maka penunjuk merupakan // panjang berkas dikurangi CHUNK_MESSAGE_SIZE. // Aktifkan dengan aturan.shifteof=true. int panjang_geser_akhir=0; size_t panjang_baca=CHUNK_MESSAGE_SIZE; if ( aturan.shifteof && kirim->ukuran_kirim + (double)CHUNK_MESSAGE_SIZE >= kirim->ukuran_berkas && kirim->ukuran_berkas - kirim->ukuran_kirim <= (double)CHUNK_MESSAGE_SIZE ){ // Pesan. DEBUG3(_("Merupakan pecahan akhir."), 0); // Jumlah geser. panjang_geser_akhir=(int)0 +((double)CHUNK_MESSAGE_SIZE -(kirim->ukuran_berkas-kirim->ukuran_kirim)); // Mengubah penunjuk berkas. penunjuk_berkas=kirim->ukuran_berkas-CHUNK_MESSAGE_SIZE; // Panjang baca. panjang_baca=CHUNK_MESSAGE_SIZE; }else{ // Jumlah geser. panjang_geser_akhir=0; // Panjang baca. panjang_baca=CHUNK_MESSAGE_SIZE; }; // Menggeser penunjuk berkas. status=fseek(pberkas, penunjuk_berkas, SEEK_SET); // Memeriksa posisi. if(status<0){ FAIL( _("Gagal memindah posisi penunjuk berkas '%1$s': %2$s (%3$i)."), nama_berkas, strerror(errno), errno ); exit(EXIT_FAILURE_IO); }else{ long posisi_sekarang=ftell(pberkas); if(posisi_sekarang<0){ FAIL( _("Gagal mendapatkan posisi penunjuk berkas '%1$s': %2$s (%3$i)."), nama_berkas, strerror(errno), errno ); exit(EXIT_FAILURE_IO); }else if(posisi_sekarang!=penunjuk_berkas){ FAIL( _("Posisi penunjuk berkas '%1$s' (%2$li) tidak sesuai. Diharapkan: %2$li."), nama_berkas, posisi_sekarang, errno ); exit(EXIT_FAILURE_IO); }else{ // Berhasil. if(kelompok_kirim>1){ DEBUG3( _("Mulai membaca di bita %1$i sebesar %2$lu bita untuk pesan %3$i kelompok %4$i."), penunjuk_berkas, (long unsigned int) panjang_baca, identifikasi, kelompok_kirim ); }else{ DEBUG3( _("Mulai membaca di bita %1$i sebesar %2$lu bita untuk pesan %3$i."), penunjuk_berkas, (long unsigned int) panjang_baca, identifikasi ); }; }; }; // Baca berkas untuk pesan. panjang_pesan=fread(pesan, 1, CHUNK_MESSAGE_SIZE, pberkas); // Menambah bita terkirim. if(identifikasi_awal || identifikasi!=identifikasi_sebelumnya){ // Menambah. identifikasi_awal=false; // kirim->ukuran_kirim+=(double)panjang_pesan; identifikasi_sebelumnya=identifikasi; kirim->identifikasi_sebelumnya=identifikasi; }; // Menggeser. if( panjang_geser_akhir>0 && panjang_geser_akhir <= CHUNK_MESSAGE_SIZE ){ // Membuat sementara. char pesan_tmp[CHUNK_MESSAGE_SIZE+1]; memset(pesan_tmp, 0, CHUNK_MESSAGE_SIZE+1); // Mengeser. panjang_pesan=CHUNK_MESSAGE_SIZE-panjang_geser_akhir; memmove(pesan_tmp+0, pesan+panjang_geser_akhir, panjang_pesan); // Mengembalikan. memset(pesan, 0, CHUNK_MESSAGE_SIZE); memcpy(pesan, pesan_tmp, panjang_pesan); // Membersihkan. memset(pesan_tmp, 0, CHUNK_MESSAGE_SIZE+1); // Pesan. DEBUG3( _("Menggeser pesan sebanyak %1$i bita."), panjang_geser_akhir ); DEBUG3( _("Mulai dibaca di bita %1$i sebesar %2$lu bita"), penunjuk_berkas+panjang_geser_akhir, panjang_pesan ); }; // Bila telah selesai. // Kecuali bila aturan.transferedcheck=true // maka penghentian melihat bita terterima Peladen // bukan bila berkas kosong. Berguna bila merupakan // sambungan paralel sehingga saat pecahan melebihi ukuran, // tidak langsung menghentikan. if ( (!panjang_pesan && !aturan.transferedcheck) || (!panjang_pesan && ( kirim->ukuran_kirim > kirim->ukuran_berkas+(CHUNK_MESSAGE_SIZE*10) ) ) ){ DEBUG3(_("Panjang pesan akhir adalah %1$i bita"), panjang_pesan); if(feof(pberkas)!=0){ // Selesai kirim. char penyangga_feof[ukuberkas_panjang]; INFO( _("Berkas '%1$s' dengan ukuran %2$s (%3$.0lf bita) telah selesai dikirim."), nama_berkas, readable_fs(kirim->ukuran_berkas, penyangga_feof), kirim->ukuran_berkas ); memset(penyangga_feof, 0, ukuberkas_panjang); clearerr(pberkas); }else if(ferror(pberkas)!=0){ // Kesalahan. FAIL( _("Gagal membaca berkas '%1$s': %2$s (%3$i)."), nama_berkas, strerror(errno), errno ); clearerr(pberkas); exit(EXIT_FAILURE_IO); }else{ // Kesalahan. WARN( _("Kesalahan berkas yang tidak diketahui: %1$s (%2$i)."), strerror(errno), errno ); }; // Pesan. DEBUG1(_("Mengirim panji '%1$s'."),_("Henti")); panji=STOP_FLAG; // Mengirim panji STOP // dan keluar dari perulangan. DEBUG1(_("Menghentikan pengulangan pengiriman."), 0); kirim->do_kirim=false; }else{ // Pesan. DEBUG3(_("Panjang pesan adalah %1$i bita"), panjang_pesan); }; }; // Bangun pesan. memcpy(pecahan, buat_pesan( pecahan, identifikasi, &paritas, pesan ), MAX_CHUNK_SIZE); // Bangun pengepala. DEBUG2(_("Panji %1$s."), arti_panji(panji)); memcpy(pecahan, buat_pengepala( pecahan, identifikasi, panji, paritas, status_gerbang, status_peladen ), MAX_CHUNK_SIZE); // Pesan. if(kelompok_kirim>1){ DEBUG1( _("Mengirim pesan %1$i kelompok %2$i."), identifikasi, kelompok_kirim); }else{ DEBUG1( _("Mengirim pesan %1$i."), identifikasi); }; // ============= Enkripsi ======= int panjang_pecahan; // Enkripsi. if(!aturan.rawtransfer){ // Pesan mentah. DEBUG5(_("Pesan mentah dikirim"), pecahan, 0, MAX_CHUNK_SIZE); // Penyandian. unsigned char pesan_ency[MAX_CHUNK_SIZE+1]; memcpy(pesan_ency, pecahan, MAX_CHUNK_SIZE); unsigned char tujuan_ency[ENCRYPTED_CONTAINER_SIZE+1]; panjang_pecahan=rsa_encrypt( pesan_ency, MAX_CHUNK_SIZE+1, tujuan_ency, rsapub, aturan.rsa_padding ); // Bersihkan. memset(pesan_ency, 0, MAX_CHUNK_SIZE); // Pesan mentah. DEBUG5( _("Pesan mentah dikirim tersandikan"), tujuan_ency, 0, MAX_CHUNK_SIZE ); // Salin. memcpy(pecahan, tujuan_ency, panjang_pecahan); }else{ panjang_pecahan=MAX_CHUNK_SIZE; }; // ============ /Enkripsi ======= // Kirim. int panjang_diterima; char *kirim_data=kirimdata( pecahan, panjang_pecahan, hostname, portno, infoalamat, &panjang_diterima ); // Bila kosong. if(kirim_data == NULL){ // Pesan kesalahan. DEBUG1(_("Kegagalan %1$s."), _("Soket")); // Keluar. exit(EXIT_FAILURE_SOCKET); }; // Menyalin isi. memcpy(pecahan, kirim_data, ENCRYPTED_CONTAINER_SIZE); // Pesan mentah. DEBUG4(_("Panjang pesan mentah diterima: %1$i"), panjang_pecahan); DEBUG5(_("Pesan mentah diterima"), pecahan, 0, panjang_pecahan); // ============= Dekripsi ======= if(!aturan.rawtransfer){ // Pemecah sandi. unsigned char pesan_deco[ENCRYPTED_CONTAINER_SIZE+1]; memcpy(pesan_deco, pecahan, ENCRYPTED_CONTAINER_SIZE); unsigned char tujuan_deco[MAX_CHUNK_SIZE+1]; panjang_pecahan=rsa_decrypt( pesan_deco, panjang_diterima, tujuan_deco, rsapriv, aturan.rsa_padding ); // Periksa. // print_unsigned_array(tujuan_deco, 100); // Bersihkan. memset(pesan_deco, 0, MAX_CHUNK_SIZE); // Pesan mentah. DEBUG4( _("Panjang pesan mentah diterima terpecahkan: %1$i"), panjang_pecahan ); DEBUG5( _("Pesan mentah diterima terpecahkan"), tujuan_deco, 0, panjang_pecahan ); // Salin. memcpy(pecahan, tujuan_deco, MAX_CHUNK_SIZE); }; // ============ /Dekripsi ======= // Mendapatkan pesan. DEBUG4(_("Membersihkan penampung pesan."), 0); memset(pesan, 0, CHUNK_MESSAGE_SIZE); DEBUG4(_("Menyalin pesan."), 0); memcpy(pesan, ambil_pesan(pecahan), CHUNK_MESSAGE_SIZE); DEBUG4(_("Selesai menyalin pesan."), 0); // Periksa. // print_unsigned_array(tujuan_deco, 100); // Mendapatkan pengepala. // Respons. int r_versi; int r_panji; int r_paritas; int r_status_gerbang; int r_status_peladen; unsigned int r_identifikasi; DEBUG4(_("Mendapatkan pengepala."), 0); ambil_pengepala( pecahan, &r_versi, &r_identifikasi, &r_panji, &r_paritas, &r_status_gerbang, &r_status_peladen ); DEBUG4(_("Selesai mendapatkan pengepala."), 0); // Mendapatkan informasi peladen. char* r_berkas_id; char* berkas_ukuran_str; char* berkas_diterima_str; char* unix_time_str; // Alikasi memori. r_berkas_id=malloc( sizeof(r_berkas_id)* (CHUNK_MESSAGE_SIZE/2)); berkas_ukuran_str=malloc( sizeof(berkas_ukuran_str)* (CHUNK_MESSAGE_SIZE/2)); berkas_diterima_str=malloc( sizeof(berkas_diterima_str)* (CHUNK_MESSAGE_SIZE/2)); unix_time_str=malloc( sizeof(unix_time_str)* (CHUNK_MESSAGE_SIZE/2)); // Membersihkan isi. memset(r_berkas_id, 0, sizeof(r_berkas_id)* (CHUNK_MESSAGE_SIZE/2)); memset(berkas_ukuran_str, 0, sizeof(berkas_ukuran_str)* (CHUNK_MESSAGE_SIZE/2)); memset(berkas_diterima_str, 0, sizeof(berkas_diterima_str)* (CHUNK_MESSAGE_SIZE/2)); memset(unix_time_str, 0, sizeof(unix_time_str)* (CHUNK_MESSAGE_SIZE/2)); // Ambil informasi. DEBUG4(_("Mendapatkan informasi peladen."), 0); DEBUG5(_("Pesan"), pesan, 0, CHUNK_MESSAGE_SIZE); status=ambil_pesan_peladen( pesan, CHUNK_MESSAGE_SIZE, &r_berkas_id, &berkas_ukuran_str, &berkas_diterima_str, &unix_time_str ); DEBUG4(_("Selesai mendapatkan informasi peladen."), 0); // Ubah nilai. double r_berkas_ukuran=0; double r_berkas_diterima=0; double r_unixtime=0; if(status>0){ // Tidak menerima. DEBUG1( _("Tidak memahami Peladen di pecahan %1$i (Status %2$i)."), r_identifikasi, status ); }else{ // Ubah nilai. r_berkas_ukuran=strtod(berkas_ukuran_str, NULL); r_berkas_diterima=strtod(berkas_diterima_str, NULL); r_unixtime=strtod(unix_time_str, NULL); }; // Balasan DEBUG2(_("Balasan: Versi: %1$i."), r_versi); DEBUG2(_("Balasan: Identifikasi: %1$i."), r_identifikasi); DEBUG2(_("Balasan: Panji: %1$s."), arti_panji(r_panji)); DEBUG2(_("Balasan: Paritas: %1$i."), r_paritas); DEBUG2(_("Balasan: Status Gerbang: %1$s."), arti_status(r_status_gerbang)); DEBUG2(_("Balasan: Status Peladen: %1$s."), arti_status(r_status_peladen)); DEBUG2(_("Balasan: Identifikasi berkas: %1$s."), r_berkas_id); DEBUG2(_("Balasan: Ukuran berkas: %1$.0f bita."), r_berkas_ukuran); DEBUG2(_("Balasan: Berkas diterima: %1$.0f bita."), r_berkas_diterima) DEBUG2(_("Balasan: Waktu Peladen: %1$.06f."), r_unixtime); DEBUG1( _("Perbedaan waktu Peladen: %1$.06f detik."), infokancil.unixtime-r_unixtime ); // Menyimpan. if(r_berkas_diterima<=0){ DEBUG2( _("Berkas terterima berukuran %1$.0f bita."), r_berkas_diterima ); }else{ kirim->ukuran_kirim=r_berkas_diterima; }; // Bila berkas yang diterima // telah sama atau lebih besar dari ukuran. if( aturan.transferedcheck && r_berkas_diterima>=kirim->ukuran_berkas ){ // Pesan. if( (r_berkas_diterima-kirim->ukuran_berkas) > (double)CHUNK_MESSAGE_SIZE * (aturan.parallel) ){ WARN( _("Peladen telah menerima berkas melebihi %1$.0f bita."), r_berkas_diterima-kirim->ukuran_berkas ); }else if(r_berkas_diterima>kirim->ukuran_berkas){ DEBUG1( _("Peladen telah menerima berkas melebihi %1$.0f bita."), r_berkas_diterima-kirim->ukuran_berkas ); }else{ DEBUG1(_("Peladen telah menerima keseluruhan berkas."), 0); }; // Ubah nilai. kirim->ukuran_kirim=r_berkas_diterima; kirim->paksa_panji=STOP_FLAG; // Keluar. return identifikasi; }; // Memeriksa hasil. // Bila status gerbang atau peladen adalah NOL. if(!r_status_gerbang || !r_status_peladen){ // Memeriksa apakah // telah terlalu banyak melakukan percobaan. if(kirim->coba>maksimal_coba){ FAIL( _("Telah melakukan percobaan sebanyak %1$i kali. Berhenti."), maksimal_coba ); exit(EXIT_FAILURE); }else if(!r_status_gerbang && !r_status_peladen){ WARN( _("Gagal mengirim ke %1$s dan %2$s."), _("Gerbang"),_("Peladen") ); }else if(!r_status_peladen){ WARN(_("Gagal mengirim ke %1$s."),_("Peladen")); }else{ WARN(_("Gagal mengirim ke %1$s."),_("Gerbang")); }; // Panji Taksah. if(r_panji==INVALID_FLAG){ // Pesan. NOTICE(_("Panji Taksah ditemukan."), 0); NOTICE( _("Menunggu %1$i detik untuk mengirim ulang."), ulang_tunggu ); sleep(ulang_tunggu); }else if(r_panji==START_FLAG){ // Mengunlang pengiriman // informasi berkas. int tunggu=ulang_tunggu; NOTICE(_("Meminta pengiriman ulang informasi berkas."), 0); NOTICE(_("Menunggu %1$i detik untuk mengirim ulang."), tunggu); sleep(tunggu); // Mengatur ulang ukuran berkas terkirim. kirim->ukuran_kirim=0; }else if(r_panji==INTRANSFER_FLAG){ // Meminta pengiriman ulang // berkas berdasarkan identifikasi. NOTICE( _("Meminta pengiriman ulang pecahan identifikasi '%1$i'."), r_identifikasi ); // Mengatur ulang ukuran berkas terkirim // sesuai dengan ukuran peladen. kirim->ukuran_kirim=r_berkas_diterima; }; // Mengirim ulang. NOTICE( _("Percobaan ke-%1$i. Mengulangi pengiriman pecahan %2$i."), kirim->coba, r_identifikasi ); identifikasi=r_identifikasi; // Menambah // percobaan pengiriman. kirim->coba++; }else{ /* // Bila ukuran terterima Peladen // lebih besar dari pada terketahui Klien. if(r_berkas_diterima> kirim->ukuran_kirim){ // Pesan. DEBUG2( _("Peladen telah menerima berkas melebihi %1$.0f bita dari yang terkirim."), r_berkas_diterima-(kirim->ukuran_berkas) ); // Ubah isi. kirim->ukuran_kirim=r_berkas_diterima; }; */ // Berhasil. DEBUG2(_("Berhasil mengirim ke Gerbang dan Peladen."), 0); // Menambahkan. identifikasi++; DEBUG2(_("Menambah identifikasi menjadi %1$i."), identifikasi); // Bila belum selesai. if(kirim->ukuran_kirim<=kirim->ukuran_berkas){ // Bila lebih dari spesifikasi, // mengulangi dari NOL. if(identifikasi>MAX_CHUNK_ID){ // Pesan. WARN( _("Telah melebihi maksimal identifikasi %1$i."), MAX_CHUNK_ID ); DEBUG1(_("Nilai identifikasi adalah %1$i."), identifikasi); // Perkembangan. tampil_info_progres_berkas( PROGRES_KIRIM, kirim->berkas, kirim->ukuran_kirim, kirim->ukuran_berkas, ukuberkas_panjang ); // Menambah kelompok. kelompok_kirim++; kirim->kelompok_kirim=kelompok_kirim; // Pesan. DEBUG1( _("Menunggu %1$i detik untuk melanjutkan."), urut_tunggu ); DEBUG1( _("Kelompok pecahan selanjutnya adalah '%1$i'."), kelompok_kirim ); // Tunggu. sleep(urut_tunggu); // Mengulangi identifikasi. identifikasi=0; }; }else{ // DEBUG1(_("Menghentikan pengulangan pengiriman."), 0); // kirim->do_kirim=false; }; kirim->coba=1; }; /* // Bila lebih dari maksimal kali kirim, // menunggu sebanyak waktu untuk mengirim ulang. if(kirim->urut_kali>=urut_maksimal && !urut_jangan_tunggu){ // Pesan. WARN( _("Telah mengirim berurutan sebanyak %1$i kali."), kirim->urut_kali ); // Perkembangan. tampil_info_progres_berkas( PROGRES_KIRIM, kirim->berkas, kirim->ukuran_kirim, kirim->ukuran_berkas, ukuberkas_panjang ); // Pesan. NOTICE(_("Menunggu %1$i detik untuk mengirim ulang."), urut_tunggu); sleep(urut_tunggu); kirim->urut_kali=0; }; */ // Memastikan nilai kelompok benar. kirim->kelompok_kirim=kelompok_kirim; // Mengembalikan nilai identifikasi. return identifikasi; // kirim->identifikasi=identifikasi; // Mengembalikan data. // kirim->berkas=berkas; // if(identifikasi>3) // kirim->do_kirim=false; }