summaryrefslogtreecommitdiff
path: root/Src/Modules
diff options
context:
space:
mode:
Diffstat (limited to 'Src/Modules')
-rw-r--r--Src/Modules/curses.c4
-rw-r--r--Src/Modules/curses.mdd2
-rw-r--r--Src/Modules/db_gdbm.c9
-rw-r--r--Src/Modules/param_private.c587
-rw-r--r--Src/Modules/param_private.mdd7
-rw-r--r--Src/Modules/socket.c23
-rw-r--r--Src/Modules/tcp.c13
-rw-r--r--Src/Modules/zftp.c8
-rw-r--r--Src/Modules/zpty.c2
9 files changed, 636 insertions, 19 deletions
diff --git a/Src/Modules/curses.c b/Src/Modules/curses.c
index 0054aef52..64329f643 100644
--- a/Src/Modules/curses.c
+++ b/Src/Modules/curses.c
@@ -370,7 +370,7 @@ zcurses_colorget(const char *nam, char *colorpair)
return NULL;
}
- cpn = (Colorpairnode)zalloc(sizeof(struct colorpairnode));
+ cpn = (Colorpairnode)zshcalloc(sizeof(struct colorpairnode));
if (!cpn) {
zsfree(cp);
@@ -462,7 +462,7 @@ zccmd_init(const char *nam, char **args)
use_default_colors();
#endif
/* Initialise the default color pair, always 0 */
- cpn = (Colorpairnode)zalloc(sizeof(struct colorpairnode));
+ cpn = (Colorpairnode)zshcalloc(sizeof(struct colorpairnode));
if (cpn) {
cpn->colorpair = 0;
addhashnode(zcurses_colorpairs,
diff --git a/Src/Modules/curses.mdd b/Src/Modules/curses.mdd
index 669c4f5c7..80c8f867b 100644
--- a/Src/Modules/curses.mdd
+++ b/Src/Modules/curses.mdd
@@ -2,7 +2,7 @@ name=zsh/curses
link='if test "x$ac_cv_func_initscr" = xyes && test "x$zsh_cv_path_curses_header" != x; then echo dynamic; else echo no; fi'
load=no
-autobins="zcurses"
+autofeatures="b:zcurses"
objects="curses.o"
diff --git a/Src/Modules/db_gdbm.c b/Src/Modules/db_gdbm.c
index 76d4751bf..032963262 100644
--- a/Src/Modules/db_gdbm.c
+++ b/Src/Modules/db_gdbm.c
@@ -106,7 +106,9 @@ bin_ztie(char *nam, char **args, Options ops, UNUSED(int func))
}
dbf = gdbm_open(resource_name, 0, read_write, 0666, 0);
- if(!dbf) {
+ if(dbf)
+ addmodulefd(gdbm_fdesc(dbf), FDT_INTERNAL);
+ else {
zwarnnam(nam, "error opening database file %s", resource_name);
return 1;
}
@@ -114,6 +116,7 @@ bin_ztie(char *nam, char **args, Options ops, UNUSED(int func))
if (!(tied_param = createspecialhash(pmname, &getgdbmnode, &scangdbmkeys,
pmflags))) {
zwarnnam(nam, "cannot create the requested parameter %s", pmname);
+ fdtable[gdbm_fdesc(dbf)] = FDT_UNUSED;
gdbm_close(dbf);
return 1;
}
@@ -319,8 +322,10 @@ gdbmuntie(Param pm)
GDBM_FILE dbf = (GDBM_FILE)(pm->u.hash->tmpdata);
HashTable ht = pm->u.hash;
- if (dbf) /* paranoia */
+ if (dbf) { /* paranoia */
+ fdtable[gdbm_fdesc(dbf)] = FDT_UNUSED;
gdbm_close(dbf);
+ }
ht->tmpdata = NULL;
diff --git a/Src/Modules/param_private.c b/Src/Modules/param_private.c
new file mode 100644
index 000000000..7f9aa7921
--- /dev/null
+++ b/Src/Modules/param_private.c
@@ -0,0 +1,587 @@
+/*
+ * param_private.c - bindings for private parameter scopes
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 2015 Barton E. Schaefer
+ * All rights reserved.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and to distribute modified versions of this software for any
+ * purpose, provided that the above copyright notice and the following
+ * two paragraphs appear in all copies of this software.
+ *
+ * In no event shall Barton E. Schaefer or the Zsh Development
+ * Group be liable to any party for direct, indirect, special, incidental, or
+ * consequential damages arising out of the use of this software and its
+ * documentation, even if Barton E. Schaefer and the Zsh
+ * Development Group have been advised of the possibility of such damage.
+ *
+ * Barton E. Schaefer and the Zsh Development Group
+ * specifically disclaim any warranties, including, but not limited to, the
+ * implied warranties of merchantability and fitness for a particular purpose.
+ * The software provided hereunder is on an "as is" basis, and
+ * Barton E. Schaefer and the Zsh Development Group have no
+ * obligation to provide maintenance, support, updates, enhancements, or
+ * modifications.
+ *
+ */
+
+#include "param_private.mdh"
+#include "param_private.pro"
+
+struct gsu_closure {
+ union {
+ struct gsu_scalar s;
+ struct gsu_integer i;
+ struct gsu_float f;
+ struct gsu_array a;
+ struct gsu_hash h;
+ } u;
+ void *g;
+};
+
+const struct gsu_scalar scalar_private_gsu =
+{ pps_getfn, pps_setfn, pps_unsetfn };
+
+const struct gsu_integer integer_private_gsu =
+{ ppi_getfn, ppi_setfn, ppi_unsetfn };
+
+const struct gsu_float float_private_gsu =
+{ ppf_getfn, ppf_setfn, ppf_unsetfn };
+
+const struct gsu_array array_private_gsu =
+{ ppa_getfn, ppa_setfn, ppa_unsetfn };
+
+const struct gsu_hash hash_private_gsu =
+{ pph_getfn, pph_setfn, pph_unsetfn };
+
+/*
+ * The trick here is:
+ *
+ * bin_private() opens a new parameter scope, then calls bin_typeset().
+ *
+ * bin_typeset() handles the usual parameter creation and error checks.
+ *
+ * makeprivate() then finds all parameters created in the new scope and
+ * rejects them if they can't be "promoted" to the surrounding scope.
+ * Otherwise it swaps out their GSU structure and promotes them so they
+ * will be removed when the surrounding scope ends.
+ *
+ * bin_private() then ends the current scope, which discards any of the
+ * parameters rejected by makeprivate().
+ *
+ */
+
+static int makeprivate_error = 0;
+
+static void
+makeprivate(HashNode hn, UNUSED(int flags))
+{
+ Param pm = (Param)hn;
+ if (pm->level == locallevel) {
+ if (pm->ename || (pm->node.flags & PM_NORESTORE) ||
+ (pm->old &&
+ (pm->old->level == locallevel - 1 ||
+ ((pm->node.flags & (PM_SPECIAL|PM_REMOVABLE)) == PM_SPECIAL &&
+ /* typeset_single() line 2300 discards PM_REMOVABLE -- why? */
+ !is_private(pm->old))))) {
+ zwarnnam("private", "can't change scope of existing param: %s",
+ pm->node.nam);
+ makeprivate_error = 1;
+ return;
+ }
+ struct gsu_closure *gsu = zhalloc(sizeof(struct gsu_closure));
+ switch (PM_TYPE(pm->node.flags)) {
+ case PM_SCALAR:
+ gsu->g = (void *)(pm->gsu.s);
+ gsu->u.s = scalar_private_gsu;
+ pm->gsu.s = (GsuScalar)gsu;
+ break;
+ case PM_INTEGER:
+ gsu->g = (void *)(pm->gsu.i);
+ gsu->u.i = integer_private_gsu;
+ pm->gsu.i = (GsuInteger)gsu;
+ break;
+ case PM_EFLOAT:
+ case PM_FFLOAT:
+ gsu->g = (void *)(pm->gsu.f);
+ gsu->u.f = float_private_gsu;
+ pm->gsu.f = (GsuFloat)gsu;
+ break;
+ case PM_ARRAY:
+ gsu->g = (void *)(pm->gsu.a);
+ gsu->u.a = array_private_gsu;
+ pm->gsu.a = (GsuArray)gsu;
+ break;
+ case PM_HASHED:
+ gsu->g = (void *)(pm->gsu.h);
+ gsu->u.h = hash_private_gsu;
+ pm->gsu.h = (GsuHash)gsu;
+ break;
+ default:
+ makeprivate_error = 1;
+ break;
+ }
+ /* PM_HIDE so new parameters in deeper scopes do not shadow */
+ pm->node.flags |= (PM_HIDE|PM_SPECIAL|PM_REMOVABLE);
+ pm->level -= 1;
+ }
+}
+
+/**/
+static int
+is_private(Param pm)
+{
+ switch (PM_TYPE(pm->node.flags)) {
+ case PM_SCALAR:
+ if (!pm->gsu.s || pm->gsu.s->unsetfn != pps_unsetfn)
+ return 0;
+ break;
+ case PM_INTEGER:
+ if (!pm->gsu.i || pm->gsu.i->unsetfn != ppi_unsetfn)
+ return 0;
+ break;
+ case PM_EFLOAT:
+ case PM_FFLOAT:
+ if (!pm->gsu.f || pm->gsu.f->unsetfn != ppf_unsetfn)
+ return 0;
+ break;
+ case PM_ARRAY:
+ if (!pm->gsu.a || pm->gsu.a->unsetfn != ppa_unsetfn)
+ return 0;
+ break;
+ case PM_HASHED:
+ if (!pm->gsu.h || pm->gsu.h->unsetfn != pph_unsetfn)
+ return 0;
+ break;
+ default:
+ /* error */
+ return 0;
+ }
+ return 1;
+}
+
+static int fakelevel;
+
+/**/
+static int
+bin_private(char *nam, char **args, LinkList assigns, Options ops, int func)
+{
+ int from_typeset = 1;
+ makeprivate_error = 0;
+
+ if (!OPT_ISSET(ops, 'P'))
+ return bin_typeset(nam, args, assigns, ops, func);
+ else if (OPT_ISSET(ops, 'T')) {
+ zwarn("bad option: -T");
+ return 1;
+ }
+
+ if (locallevel == 0) {
+ if (isset(WARNCREATEGLOBAL))
+ zwarnnam(nam, "invalid local scope, using globals");
+ return bin_typeset("private", args, assigns, ops, func);
+ }
+
+ ops->ind['g'] = 2; /* force bin_typeset() to behave as "local" */
+
+ queue_signals();
+ fakelevel = locallevel;
+ startparamscope();
+ from_typeset = bin_typeset("private", args, assigns, ops, func);
+ scanhashtable(paramtab, 0, 0, 0, makeprivate, 0);
+ endparamscope();
+ fakelevel = 0;
+ unqueue_signals();
+
+ return makeprivate_error | from_typeset;
+}
+
+static void
+setfn_error(Param pm)
+{
+ pm->node.flags |= PM_UNSET;
+ zerr("%s: attempt to assign private in nested scope", pm->node.nam);
+}
+
+/*
+ * How the GSU functions work:
+ *
+ * The getfn and setfn family compare to locallevel and then call through
+ * to the original getfn or setfn. This means you can't assign at a
+ * deeper scope to any parameter declared private unless you first declare
+ * it local again at the new scope. Testing locallevel in getfn is most
+ * likely unnecessary given the scopeprivate() wrapper installed below.
+ *
+ * The unsetfn family compare locallevel and restore the old GSU before
+ * calling the original unsetfn. This assures that if the old unsetfn
+ * wants to use its getfn or setfn, they're unconditionally present.
+ *
+ */
+
+/**/
+static char *
+pps_getfn(Param pm)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.s);
+ GsuScalar gsu = (GsuScalar)(c->g);
+
+ if (locallevel >= pm->level)
+ return gsu->getfn(pm);
+ else
+ return (char *) hcalloc(1);
+}
+
+/**/
+static void
+pps_setfn(Param pm, char *x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.s);
+ GsuScalar gsu = (GsuScalar)(c->g);
+ if (locallevel == pm->level)
+ gsu->setfn(pm, x);
+ else
+ setfn_error(pm);
+}
+
+/**/
+static void
+pps_unsetfn(Param pm, int x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.s);
+ GsuScalar gsu = (GsuScalar)(c->g);
+ pm->gsu.s = gsu;
+ if (locallevel <= pm->level)
+ gsu->unsetfn(pm, x);
+}
+
+/**/
+static zlong
+ppi_getfn(Param pm)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.i);
+ GsuInteger gsu = (GsuInteger)(c->g);
+ if (locallevel >= pm->level)
+ return gsu->getfn(pm);
+ else
+ return 0;
+}
+
+/**/
+static void
+ppi_setfn(Param pm, zlong x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.i);
+ GsuInteger gsu = (GsuInteger)(c->g);
+ if (locallevel == pm->level)
+ gsu->setfn(pm, x);
+ else
+ setfn_error(pm);
+}
+
+/**/
+static void
+ppi_unsetfn(Param pm, int x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.i);
+ GsuInteger gsu = (GsuInteger)(c->g);
+ pm->gsu.i = gsu;
+ if (locallevel <= pm->level)
+ gsu->unsetfn(pm, x);
+}
+
+/**/
+static double
+ppf_getfn(Param pm)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.f);
+ GsuFloat gsu = (GsuFloat)(c->g);
+ if (locallevel >= pm->level)
+ return gsu->getfn(pm);
+ else
+ return 0;
+}
+
+/**/
+static void
+ppf_setfn(Param pm, double x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.f);
+ GsuFloat gsu = (GsuFloat)(c->g);
+ if (locallevel == pm->level)
+ gsu->setfn(pm, x);
+ else
+ setfn_error(pm);
+}
+
+/**/
+static void
+ppf_unsetfn(Param pm, int x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.f);
+ GsuFloat gsu = (GsuFloat)(c->g);
+ pm->gsu.f = gsu;
+ if (locallevel <= pm->level)
+ gsu->unsetfn(pm, x);
+}
+
+/**/
+static char **
+ppa_getfn(Param pm)
+{
+ static char *nullarray = NULL;
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.a);
+ GsuArray gsu = (GsuArray)(c->g);
+ if (locallevel >= pm->level)
+ return gsu->getfn(pm);
+ else
+ return &nullarray;
+}
+
+/**/
+static void
+ppa_setfn(Param pm, char **x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.a);
+ GsuArray gsu = (GsuArray)(c->g);
+ if (locallevel == pm->level)
+ gsu->setfn(pm, x);
+ else
+ setfn_error(pm);
+}
+
+/**/
+static void
+ppa_unsetfn(Param pm, int x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.a);
+ GsuArray gsu = (GsuArray)(c->g);
+ pm->gsu.a = gsu;
+ if (locallevel <= pm->level)
+ gsu->unsetfn(pm, x);
+}
+
+static HashTable emptytable;
+
+/**/
+static HashTable
+pph_getfn(Param pm)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.h);
+ GsuHash gsu = (GsuHash)(c->g);
+ if (locallevel >= pm->level)
+ return gsu->getfn(pm);
+ else
+ return emptytable;
+}
+
+/**/
+static void
+pph_setfn(Param pm, HashTable x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.h);
+ GsuHash gsu = (GsuHash)(c->g);
+ if (locallevel == pm->level)
+ gsu->setfn(pm, x);
+ else
+ setfn_error(pm);
+}
+
+/**/
+static void
+pph_unsetfn(Param pm, int x)
+{
+ struct gsu_closure *c = (struct gsu_closure *)(pm->gsu.h);
+ GsuHash gsu = (GsuHash)(c->g);
+ pm->gsu.h = gsu;
+ if (locallevel <= pm->level)
+ gsu->unsetfn(pm, x);
+}
+
+/*
+ * How visibility works:
+ *
+ * Upon entering a new function scope, we find all the private parameters
+ * at this locallevel. Any that we find are marked PM_UNSET. If they are
+ * already unset, they are also marked as PM_NORESTORE.
+ *
+ * On exit from the scope, we find the same parameters again and remove
+ * the PM_UNSET and PM_NORESTORE flags as appropriate. We're guaraneed
+ * by makeprivate() that PM_NORESTORE won't conflict with anything here.
+ *
+ */
+
+static void
+scopeprivate(HashNode hn, int onoff)
+{
+ Param pm = (Param)hn;
+ if (pm->level == locallevel) {
+ if (!is_private(pm))
+ return;
+ if (onoff == PM_UNSET)
+ if (pm->node.flags & PM_UNSET)
+ pm->node.flags |= PM_NORESTORE;
+ else
+ pm->node.flags |= PM_UNSET;
+ else if (!(pm->node.flags & PM_NORESTORE))
+ pm->node.flags &= ~PM_UNSET;
+ pm->node.flags &= ~PM_NORESTORE;
+ }
+}
+
+static struct funcwrap wrapper[] = {
+ WRAPDEF(wrap_private)
+};
+
+/**/
+static int
+wrap_private(Eprog prog, FuncWrap w, char *name)
+{
+ static int wraplevel = 0;
+
+ if (wraplevel < locallevel /* && strcmp(name, "(anon)") != 0 */) {
+ int owl = wraplevel;
+ wraplevel = locallevel;
+ scanhashtable(paramtab, 0, 0, 0, scopeprivate, PM_UNSET);
+ runshfunc(prog, w, name);
+ scanhashtable(paramtab, 0, 0, 0, scopeprivate, 0);
+ wraplevel = owl;
+ return 0;
+ }
+ return 1;
+}
+
+static HashNode (*getparamnode) _((HashTable, const char *));
+
+/**/
+static HashNode
+getprivatenode(HashTable ht, const char *nam)
+{
+ HashNode hn = getparamnode(ht, nam);
+ Param pm = (Param) hn;
+
+ while (!fakelevel && pm && locallevel > pm->level && is_private(pm))
+ pm = pm->old;
+ return (HashNode)pm;
+}
+
+/**/
+static HashNode
+getprivatenode2(HashTable ht, const char *nam)
+{
+ /* getparamnode() would follow autoloads, we must not do that here */
+ HashNode hn = gethashnode2(ht, nam);
+ Param pm = (Param) hn;
+
+ while (!fakelevel && pm && locallevel > pm->level && is_private(pm))
+ pm = pm->old;
+ return (HashNode)pm;
+}
+
+/**/
+static void
+printprivatenode(HashNode hn, int printflags)
+{
+ Param pm = (Param) hn;
+ while (pm && (!fakelevel ||
+ (fakelevel > pm->level && (pm->node.flags & PM_UNSET))) &&
+ locallevel > pm->level && is_private(pm))
+ pm = pm->old;
+ /* Ideally, we'd print the word "private" here instead of "typeset"
+ * when the parameter is in fact a private, but that would require
+ * re-implementing the entirety of printparamnode(). */
+ if (pm)
+ printparamnode((HashNode)pm, printflags);
+}
+
+/*
+ * Standard module configuration/linkage
+ */
+
+static struct builtin bintab[] = {
+ /* Copied from BUILTIN("local"), "P" added */
+ BUILTIN("private", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL | BINF_ASSIGN, (HandlerFunc)bin_private, 0, -1, 0, "AE:%F:%HL:%PR:%TUZ:%ahi:%lprtux", "P")
+};
+
+static struct features module_features = {
+ bintab, sizeof(bintab)/sizeof(*bintab),
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ 0
+};
+
+static struct builtin save_local;
+static struct reswd reswd_private = {{NULL, "private", 0}, TYPESET};
+
+/**/
+int
+setup_(UNUSED(Module m))
+{
+ HashNode hn = builtintab->getnode(builtintab, "local");
+
+ /* Horrible, horrible hack */
+ getparamnode = realparamtab->getnode;
+ realparamtab->getnode = getprivatenode;
+ realparamtab->getnode2 = getprivatenode2;
+ realparamtab->printnode = printprivatenode;
+
+ /* Even more horrible hack */
+ save_local = *(Builtin)hn;
+ ((Builtin)hn)->handlerfunc = bintab[0].handlerfunc;
+ ((Builtin)hn)->optstr = bintab[0].optstr;
+
+ reswdtab->addnode(reswdtab, reswd_private.node.nam, &reswd_private);
+
+ return 0;
+}
+
+/**/
+int
+features_(Module m, char ***features)
+{
+ *features = featuresarray(m, &module_features);
+ return 0;
+}
+
+/**/
+int
+enables_(Module m, int **enables)
+{
+ return handlefeatures(m, &module_features, enables);
+}
+
+/**/
+int
+boot_(Module m)
+{
+ emptytable = newparamtable(1, "private");
+ return addwrapper(m, wrapper);
+}
+
+/**/
+int
+cleanup_(Module m)
+{
+ HashNode hn = builtintab->getnode(builtintab, "local");
+ *(Builtin)hn = save_local;
+
+ removehashnode(reswdtab, "private");
+
+ realparamtab->getnode = getparamnode;
+ realparamtab->getnode2 = gethashnode2;
+ realparamtab->printnode = printparamnode;
+
+ deletewrapper(m, wrapper);
+ return setfeatureenables(m, &module_features, NULL);
+}
+
+/**/
+int
+finish_(UNUSED(Module m))
+{
+ deletehashtable(emptytable);
+ return 0;
+}
diff --git a/Src/Modules/param_private.mdd b/Src/Modules/param_private.mdd
new file mode 100644
index 000000000..e6eb3228f
--- /dev/null
+++ b/Src/Modules/param_private.mdd
@@ -0,0 +1,7 @@
+name=zsh/param/private
+link=dynamic
+load=yes
+
+autofeatures="b:private"
+
+objects="param_private.o"
diff --git a/Src/Modules/socket.c b/Src/Modules/socket.c
index 65b87d7dd..7c3fb5ebe 100644
--- a/Src/Modules/socket.c
+++ b/Src/Modules/socket.c
@@ -115,6 +115,8 @@ bin_zsocket(char *nam, char **args, Options ops, UNUSED(int func))
return 1;
}
+ addmodulefd(sfd, FDT_EXTERNAL);
+
if (targetfd) {
sfd = redup(sfd, targetfd);
}
@@ -127,7 +129,10 @@ bin_zsocket(char *nam, char **args, Options ops, UNUSED(int func))
return 1;
}
- setiparam("REPLY", sfd);
+ /* allow to be closed explicitly */
+ fdtable[sfd] = FDT_EXTERNAL;
+
+ setiparam_no_convert("REPLY", (zlong)sfd);
if (verbose)
printf("%s listener is on fd %d\n", soun.sun_path, sfd);
@@ -200,18 +205,22 @@ bin_zsocket(char *nam, char **args, Options ops, UNUSED(int func))
return 1;
}
+ addmodulefd(rfd, FDT_EXTERNAL);
+
if (targetfd) {
sfd = redup(rfd, targetfd);
if (sfd < 0) {
zerrnam(nam, "could not duplicate socket fd to %d: %e", targetfd, errno);
+ zclose(rfd);
return 1;
}
+ fdtable[sfd] = FDT_EXTERNAL;
}
else {
sfd = rfd;
}
- setiparam("REPLY", sfd);
+ setiparam_no_convert("REPLY", (zlong)sfd);
if (verbose)
printf("new connection from %s is on fd %d\n", soun.sun_path, sfd);
@@ -240,15 +249,19 @@ bin_zsocket(char *nam, char **args, Options ops, UNUSED(int func))
}
else
{
+ addmodulefd(sfd, FDT_EXTERNAL);
+
if (targetfd) {
- sfd = redup(sfd, targetfd);
- if (sfd < 0) {
+ if (redup(sfd, targetfd) < 0) {
zerrnam(nam, "could not duplicate socket fd to %d: %e", targetfd, errno);
+ zclose(sfd);
return 1;
}
+ sfd = targetfd;
+ fdtable[sfd] = FDT_EXTERNAL;
}
- setiparam("REPLY", sfd);
+ setiparam_no_convert("REPLY", (zlong)sfd);
if (verbose)
printf("%s is now on fd %d\n", soun.sun_path, sfd);
diff --git a/Src/Modules/tcp.c b/Src/Modules/tcp.c
index bc1765da1..9fc1b29a2 100644
--- a/Src/Modules/tcp.c
+++ b/Src/Modules/tcp.c
@@ -236,6 +236,8 @@ tcp_socket(int domain, int type, int protocol, int ztflags)
if (!sess) return NULL;
sess->fd = socket(domain, type, protocol);
+ /* We'll check failure and tidy up in caller */
+ addmodulefd(sess->fd, FDT_MODULE);
return sess;
}
@@ -298,7 +300,7 @@ tcp_close(Tcp_session sess)
{
if (sess->fd != -1)
{
- err = close(sess->fd);
+ err = zclose(sess->fd);
if (err)
zwarn("connection close failed: %e", errno);
}
@@ -459,7 +461,7 @@ bin_ztcp(char *nam, char **args, Options ops, UNUSED(int func))
return 1;
}
- setiparam("REPLY", sess->fd);
+ setiparam_no_convert("REPLY", (zlong)sess->fd);
if (verbose)
printf("%d listener is on fd %d\n", ntohs(sess->sock.in.sin_port), sess->fd);
@@ -546,6 +548,9 @@ bin_ztcp(char *nam, char **args, Options ops, UNUSED(int func))
return 1;
}
+ /* redup expects fd is already registered */
+ addmodulefd(rfd, FDT_MODULE);
+
if (targetfd) {
sess->fd = redup(rfd, targetfd);
if (sess->fd < 0) {
@@ -557,7 +562,7 @@ bin_ztcp(char *nam, char **args, Options ops, UNUSED(int func))
sess->fd = rfd;
}
- setiparam("REPLY", sess->fd);
+ setiparam_no_convert("REPLY", (zlong)sess->fd);
if (verbose)
printf("%d is on fd %d\n", ntohs(sess->peer.in.sin_port), sess->fd);
@@ -676,7 +681,7 @@ bin_ztcp(char *nam, char **args, Options ops, UNUSED(int func))
}
}
- setiparam("REPLY", sess->fd);
+ setiparam_no_convert("REPLY", (zlong)sess->fd);
if (verbose)
printf("%s:%d is now on fd %d\n",
diff --git a/Src/Modules/zftp.c b/Src/Modules/zftp.c
index bd51512f9..b4081df5f 100644
--- a/Src/Modules/zftp.c
+++ b/Src/Modules/zftp.c
@@ -409,7 +409,7 @@ zfalarm(int tmout)
/**/
static void
-zfpipe()
+zfpipe(void)
{
/* Just ignore SIGPIPE and rely on getting EPIPE from the write. */
signal(SIGPIPE, SIG_IGN);
@@ -450,7 +450,7 @@ zfunalarm(void)
/**/
static void
-zfunpipe()
+zfunpipe(void)
{
if (sigtrapped[SIGPIPE]) {
if (siglists[SIGPIPE] || (sigtrapped[SIGPIPE] & ZSIG_FUNC))
@@ -1298,7 +1298,7 @@ zfstarttrans(char *nam, int recv, off_t sz)
/**/
static void
-zfendtrans()
+zfendtrans(void)
{
zfunsetparam("ZFTP_SIZE");
zfunsetparam("ZFTP_FILE");
@@ -2834,7 +2834,7 @@ newsession(char *nm)
/* Save the existing session: this just means saving the parameters. */
static void
-savesession()
+savesession(void)
{
char **ps, **pd, *val;
diff --git a/Src/Modules/zpty.c b/Src/Modules/zpty.c
index 9741ee287..3b8366076 100644
--- a/Src/Modules/zpty.c
+++ b/Src/Modules/zpty.c
@@ -464,7 +464,7 @@ newptycmd(char *nam, char *pname, char **args, int echo, int nblock)
#endif
errno == EINTR));
- setiparam("REPLY", master);
+ setiparam_no_convert("REPLY", (zlong)master);
return 0;
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-10 14:34:14 +0000