/* This file is part of GNUnet. (C) 2003, 2004, 2006, 2009 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNUnet; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /** * @file fs/fs_unindex.c * @author Krista Bennett * @author Christian Grothoff * @brief Unindex file. * * TODO: * - code cleanup (share more with upload.c) */ #include "platform.h" #include "gnunet_constants.h" #include "gnunet_fs_service.h" #include "gnunet_protocols.h" #include "fs.h" /** * Fill in all of the generic fields for * an unindex event. * * @param pc structure to fill in * @param sc overall unindex context */ static void make_unindex_status (struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_UnindexContext *uc) { pi->value.unindex.uc = uc; pi->value.unindex.cctx = uc->client_info; pi->value.unindex.filename = uc->filename; pi->value.unindex.size = uc->file_size; pi->value.unindex.eta = GNUNET_TIME_calculate_eta (uc->start_time, uc->unindex_offset, uc->file_size); pi->value.publish.duration = GNUNET_TIME_absolute_get_duration (uc->start_time); pi->value.publish.completed = uc->unindex_offset; } /** * We've encountered an error during * unindexing. Signal the client. * * @param uc context for the failed unindexing operation * @param emsg the error message */ static void signal_unindex_error (struct GNUNET_FS_UnindexContext *uc, const char *emsg) { struct GNUNET_FS_ProgressInfo pi; pi.status = GNUNET_FS_STATUS_UNINDEX_ERROR; make_unindex_status (&pi, uc); pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL; pi.value.unindex.specifics.error.message = emsg; uc->client_info = uc->h->upcb (uc->h->upcb_cls, &pi); } /** * Function called with the response from the * FS service to our unindexing request. * * @param cls closure, unindex context * @param msg NULL on timeout, otherwise the response */ static void process_fs_response (void *cls, const struct GNUNET_MessageHeader *msg) { struct GNUNET_FS_UnindexContext *uc = cls; GNUNET_CLIENT_disconnect (uc->client); uc->client = NULL; if (uc->state != UNINDEX_STATE_FS_NOTIFY) { GNUNET_FS_unindex_stop (uc); return; } if (NULL == msg) { uc->state = UNINDEX_STATE_ERROR; signal_unindex_error (uc, _("Timeout waiting for `fs' service.")); return; } if (ntohs(msg->type) != GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK) { uc->state = UNINDEX_STATE_ERROR; signal_unindex_error (uc, _("Invalid response from `fs' service.")); return; } uc->state = UNINDEX_STATE_DS_REMOVE; uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg, uc->h->sched); if (NULL == uc->dsh) { uc->state = UNINDEX_STATE_ERROR; signal_unindex_error (uc, _("Failed to connect to `datastore' service.")); return; } // FIXME: call shared code with publishing... } /** * Function called once the hash of the file * that is being unindexed has been computed. * * @param cls closure, unindex context * @param file_id computed hash, NULL on error */ static void process_hash (void *cls, const GNUNET_HashCode *file_id) { struct GNUNET_FS_UnindexContext *uc = cls; struct UnindexMessage req; if (uc->state != UNINDEX_STATE_HASHING) { GNUNET_FS_unindex_stop (uc); return; } if (file_id == NULL) { uc->state = UNINDEX_STATE_ERROR; signal_unindex_error (uc, _("Failed to compute hash of file.")); return; } uc->file_id = *file_id; uc->state = UNINDEX_STATE_FS_NOTIFY; uc->client = GNUNET_CLIENT_connect (uc->h->sched, "fs", uc->h->cfg); req.header.size = htons (sizeof (struct UnindexMessage)); req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX); req.reserved = 0; req.file_id = *file_id; GNUNET_CLIENT_transmit_and_get_response (uc->client, &req.header, GNUNET_CONSTANTS_SERVICE_TIMEOUT, &process_fs_response, uc); } /** * Unindex a file. * * @param h handle to the file sharing subsystem * @param filename file to unindex * @return NULL on error, otherwise handle */ struct GNUNET_FS_UnindexContext * GNUNET_FS_unindex (struct GNUNET_FS_Handle *h, const char *filename) { struct GNUNET_FS_UnindexContext *ret; struct GNUNET_FS_ProgressInfo pi; uint64_t size; if (GNUNET_OK != GNUNET_DISK_file_size (filename, &size, GNUNET_YES)) return NULL; ret = GNUNET_malloc (sizeof (struct GNUNET_FS_UnindexContext)); ret->h = h; ret->filename = GNUNET_strdup (filename); ret->start_time = GNUNET_TIME_absolute_get (); ret->file_size = size; // FIXME: make persistent! pi.status = GNUNET_FS_STATUS_UNINDEX_START; make_unindex_status (&pi, ret); pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL; ret->client_info = h->upcb (h->upcb_cls, &pi); GNUNET_CRYPTO_hash_file (h->sched, GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_NO, filename, HASHING_BLOCKSIZE, &process_hash, ret); return ret; } /** * Clean up after completion of an unindex operation. * * @param uc handle */ void GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc) { struct GNUNET_FS_ProgressInfo pi; if ( (uc->state != UNINDEX_STATE_COMPLETE) && (uc->state != UNINDEX_STATE_ERROR) ) { uc->state = UNINDEX_STATE_ABORTED; return; } // FIXME: make unpersistent! pi.status = GNUNET_FS_STATUS_UNINDEX_STOPPED; make_unindex_status (&pi, uc); pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO; uc->client_info = uc->h->upcb (uc->h->upcb_cls, &pi); GNUNET_break (NULL == uc->client_info); GNUNET_free (uc->filename); GNUNET_free (uc); } /* end of fs_unindex.c */