/*
* cdb, cdb-wr - Tcl bindings for tinycdb and a journalling write extension
- * Copyright 2006 Ian Jackson
+ * Copyright 2006-2012 Ian Jackson
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301, USA.
+ * along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "chiark_tcl_cdb.h"
+#define KEYLEN_MAX (INT_MAX/2)
+
#define ftello ftell
#define fseeko fseek
#define MAX_SUFFIX 5
static void pathbuf_init(Pathbuf *pb, const char *pathb) {
- int l= strlen(pathb);
+ size_t l= strlen(pathb);
+ assert(l < INT_MAX);
pb->buf= TALLOC(l + MAX_SUFFIX + 1);
memcpy(pb->buf, pathb, l);
pb->sfx= pb->buf + l;
static HashValue *htv_prep(int len) {
HashValue *hd;
- hd= TALLOC((hd->data - (Byte*)hd) + len);
+ hd= TALLOC(offsetof(typeof(*hd), data) + len);
hd->len= len;
return hd;
}
int ix, autocompact;
int cdb_fd, lock_fd;
struct cdb cdb; /* valid iff cdb_fd >= 0 */
- FILE *logfile;
+ FILE *logfile; /* may be 0; if so, is broken */
HashTable logincore;
Pathbuf pbsome, pbother;
off_t mainsz;
ScriptToInvoke on_info, on_lexminval;
} Rw;
+static void rw_cdb_close(Tcl_Interp *ip, Rw *rw) {
+ if (rw->cdb_fd >= 0) cdb_free(&rw->cdb);
+ maybe_close(rw->cdb_fd);
+}
+
static int rw_close(Tcl_Interp *ip, Rw *rw) {
int rc, r;
rc= TCL_OK;
ht_destroy(&rw->logincore);
- if (rw->cdb_fd >= 0) cdb_free(&rw->cdb);
- maybe_close(rw->cdb_fd);
+ rw_cdb_close(ip,rw);
maybe_close(rw->lock_fd);
if (rw->logfile) {
*p= 0;
errno=0; ul= strtoul(numbuf, &ep, 10);
- if (*ep || errno || ul >= INT_MAX/2) return -2;
+ if (*ep || errno || ul >= KEYLEN_MAX) return -2;
*num_r= ul;
return 0;
}
static int writerecord(FILE *f, const char *key, const HashValue *val) {
int r;
- r= fprintf(f, "+%d,%d:%s->", strlen(key), val->len, key);
+ r= fprintf(f, "+%d,%d:%s->", (int)strlen(key), val->len, key);
if (r<0) return -1;
r= fwrite(val->data, 1, val->len, f);
/*---------- Opening ----------*/
static int cdbinit(Tcl_Interp *ip, Rw *rw) {
- /* On entry, cdb_fd >=0 but cdb is _undefined_/
+ /* On entry, cdb_fd >=0 but cdb is _undefined_
* On exit, either cdb_fd<0 or cdb is initialised */
int r, rc;
a.reccount= reccount_r;
r= fclose(rw->logfile);
+ rw->logfile= 0;
if (r) { rc= cht_posixerr(ip, errno, "probable data loss! failed to fclose"
" logfile during compact"); goto x_rc; }
- rw->logfile= 0;
rc= infocb(ip, rw, "compact-start", "log=%luby main=%luby",
logsz, (unsigned long)rw->mainsz);
if (!a.mainfile) PE("create .tmp for new main during compact");
r= ht_forall(&rw->logincore, addto_main, &a);
- if (r) { rc= cht_posixerr(ip, r, "error writing to new .main"
+ if (r) { rc= cht_posixerr(ip, errno, "error writing to new .main"
" during compact"); goto x_rc; }
r= putc('\n', a.mainfile);
rc= compact_core(ip, rw, logsz, &reccount); if (rc) goto x_rc;
- maybe_close(rw->cdb_fd);
- rw->cdb_fd= -1;
+ rw_cdb_close(ip,rw);
ht_destroy(&rw->logincore);
ht_setup(&rw->logincore);
static int update(Tcl_Interp *ip, Rw *rw, const char *key,
const Byte *data, int dlen) {
HashValue *val;
+ const char *failed;
int rc, r;
+ off_t recstart;
+
+ if (strlen(key) >= KEYLEN_MAX)
+ return cht_staticerr(ip, "key too long", "CDB KEYOVERFLOW");
if (!rw->logfile) return cht_staticerr
- (ip, "previous compact failed; cdbwr must be closed and reopened "
- "before any further updates", "CDB BROKEN");
+ (ip, "failure during previous compact or error recovery;"
+ " cdbwr must be closed and reopened before any further updates",
+ "CDB BROKEN");
+ recstart= ftello(rw->logfile);
+ if (recstart < 0)
+ return cht_posixerr(ip, errno, "failed to ftello .jrn during update");
+
val= htv_prep(dlen); assert(val);
memcpy(htv_fillptr(val), data, dlen);
x_rc:
TFREE(val);
+ assert(rc);
+
+ /* Now, we have to try to sort out the journal so that it's
+ * truncated and positioned to where this abortively-written record
+ * started, with no buffered output and the error indicator clear.
+ *
+ * There seems to be no portable way to ensure the buffered unwritten
+ * output is discarded, so we close and reopen the stream.
+ */
+ fclose(rw->logfile);
+
+ rw->logfile= fopen(pathbuf_sfx(&rw->pbsome,".jrn"), "r+");
+ if (!rw->logfile) { failed= "fopen"; goto reset_fail; }
+
+ r= ftruncate(fileno(rw->logfile), recstart);
+ if (r) { failed= "ftruncate"; goto reset_fail; }
+
+ r= fseeko(rw->logfile, recstart, SEEK_SET);
+ if (r) { failed= "fseeko"; goto reset_fail; }
+
+ return rc;
+
+ reset_fail:
+ Tcl_AppendResult(ip, " (additionally, ", failed, " failed"
+ " in error recovery: ", strerror(errno), ")", (char*)0);
+ if (rw->logfile) { fclose(rw->logfile); rw->logfile= 0; }
+
return rc;
}
val= ht_lookup(&rw->logincore, key);
if (val) {
if (val->len) { *data_r= val->data; *len_r= val->len; return TCL_OK; }
- else { *data_r= 0; *len_r= -1; return TCL_OK; }
+ else goto not_found;
}
+ if (rw->cdb_fd<0) goto not_found;
+
return cht_cdb_lookup_cdb(ip, &rw->cdb, key, strlen(key), data_r, len_r);
-}
+
+ not_found:
+ *data_r= 0;
+ *len_r= -1;
+ return TCL_OK;
+}
int cht_do_cdbwr_lookup(ClientData cd, Tcl_Interp *ip, void *rw_v,
const char *key, Tcl_Obj *def,
return cht_cdb_donesomelookup(ip, rw_v, def, result, data, dlen,
cht_cdb_storeanswer_hb);
}
-
-int cht_do_cdbtoplevel_cdb_wr(ClientData cd, Tcl_Interp *ip,
- const Cdbwr_SubCommand* subcmd,
- int objc, Tcl_Obj *const *objv) {
- return subcmd->func((void*)subcmd,ip,objc,objv);
-}