TNC_Result TNC_TNCS_ReportMessageTypesLong(
/*in*/  TNC_IMVID imvID,
/*in*/  TNC_VendorIDList supportedVendorIDs,
/*in*/  TNC_MessageSubtypeList supportedSubtypes,
/*in*/  TNC_UInt32 typeCount)
{
    unsigned i;

    if( typeCount > g_nImvMessageLongSubtypesCount )
	{
		g_pImvMessageLongSubtypes = (TNC_MessageSubtypeList) realloc( g_pImvMessageLongSubtypes, sizeof( *supportedSubtypes ) * typeCount );
		g_pImvVendorIDs = (TNC_VendorIDList) realloc( g_pImvVendorIDs, sizeof(TNC_VendorID) * typeCount );
	}

    outfmt( OUT_LEVEL_NORMAL, "< TNC_TNCS_ReportMessageTypesLong (IMV %d)", imvID );
    if( typeCount > 0 )
    {
        memcpy( g_pImvMessageLongSubtypes, supportedSubtypes, sizeof( *supportedSubtypes ) * typeCount );
		memcpy( g_pImvVendorIDs, supportedVendorIDs, sizeof( *supportedVendorIDs ) * typeCount );
        g_nImvMessageLongSubtypesCount = typeCount;

        for( i=0; i < typeCount; ++i )
			outfmt( OUT_LEVEL_NORMAL, "%c(vendor ID %#x, message subtype %#x)%c", 
                0 == i ? '\n' : ' ', 
				g_pImvVendorIDs[i],
                g_pImvMessageLongSubtypes[i], 
                i == typeCount - 1 ? '\n' : ',' );
    }
    else
	{
        outfmt( OUT_LEVEL_NORMAL, "\nEmpty message list. No messages will be delivered to this IMV!\n" );
	}

    return TNC_RESULT_SUCCESS;
}

TNC_Result TNC_TNCS_SendMessageLong(
/*in*/  TNC_IMVID imvID,
/*in*/  TNC_ConnectionID connectionID,
/*in*/  TNC_UInt32 messageFlags,
/*in*/  TNC_BufferReference message,
/*in*/  TNC_UInt32 messageLength,
/*in*/  TNC_VendorID messageVendorID,
/*in*/  TNC_MessageSubtype messageSubtype,
/*in*/  TNC_UInt32 destinationIMCID)
{
	MESSAGE_LONG  longTypeMessage;

    outfmt( OUT_LEVEL_NORMAL, "< TNC_TNCS_SendMessageLong: IMV %d, CID %d, "
		"msg length %d, vendor ID %#x msg subtype %#x, msg flags %#x, destIMCID %#x\n", 
        imvID, connectionID, messageLength, messageVendorID, 
		messageSubtype, messageFlags, destinationIMCID );

    outfmt( OUT_LEVEL_VERBOSE, "< IMC message data:\n" );
    outmessage( OUT_LEVEL_VERBOSE, message, messageLength );

	longTypeMessage.imcID = destinationIMCID;
	longTypeMessage.imvID = imvID;
	longTypeMessage.message = message;
	longTypeMessage.messageFlags = messageFlags;
	longTypeMessage.messageLength = messageLength;
	longTypeMessage.messageSubtype = messageSubtype;
	longTypeMessage.messageVendorID = messageVendorID;

    QueueAddMessageLong( &longTypeMessage );

    return TNC_RESULT_SUCCESS;
}

static void
exvwarning(int sv_errno, const char *msg, va_list ap)
{
	/* Partially emulate line buffered output so that:
	 *	printf '%d\n' 1 a 2
	 * and
	 *	printf '%d %d %d\n' 1 a 2
	 * both generate sensible text when stdout and stderr are merged.
	 */
	if (output.nextc != output.buf && output.nextc[-1] == '\n')
		flushout(&output);
	if (commandname)
		outfmt(&errout, "%s: ", commandname);
	else
		outfmt(&errout, "%s: ", getprogname());
	if (msg != NULL) {
		doformat(&errout, msg, ap);
		if (sv_errno >= 0)
			outfmt(&errout, ": ");
	}
	if (sv_errno >= 0)
		outfmt(&errout, "%s", strerror(sv_errno));
	out2c('\n');
	flushout(&errout);
}

STATIC void
synerror(char *msg)
{
	if (commandname)
		outfmt(&errout, "%s: %d: ", commandname, startlinno);
	outfmt(&errout, "Syntax error: %s\n", msg);
	error((char *)NULL);
}

void
setterm(const char *term)
{
	if (el != NULL && term != NULL)
		if (el_set(el, EL_TERMINAL, term) != 0) {
			outfmt(out2, "sh: Can't set terminal type %s\n", term);
			outfmt(out2, "sh: Using dumb terminal settings.\n");
		}
}

static void
vwarning(const char *msg, va_list ap)
{
	if (commandname)
		outfmt(out2, "%s: ", commandname);
	else if (arg0)
		outfmt(out2, "%s: ", arg0);
	doformat(out2, msg, ap);
	out2fmt_flush("\n");
}

unsigned ImvBatchEnding( TNC_ConnectionID cid )
{
    TNC_Result rc = TNC_RESULT_SUCCESS;

    if( NULL != imvFuncs.pfnBatchEnding )
    {
        outfmt( OUT_LEVEL_NORMAL, "> TNC_IMV_BatchEnding (IMV: %d, CID: %d)\n", IMV_ID, cid );
        rc = imvFuncs.pfnBatchEnding( IMV_ID, cid );
        outfmt( OUT_LEVEL_NORMAL, "> TNC_IMV_BatchEnding result: %d\n", rc );
    }

    return rc;
}

int LoadIMV(const char *dllPath)
{
    int err;

	outfmt( OUT_LEVEL_NORMAL, "Loading IMV DLL: \"%s\"...", dllPath );
    err = LoadImvDLL( dllPath, &imvFuncs );
    if (err) 
    {
        outfmt( OUT_LEVEL_NORMAL, " Error %d.\n", err);
        return TNC_RESULT_OTHER;
    }

    outfmt( OUT_LEVEL_NORMAL, " Ok\n" );
    return TNC_RESULT_SUCCESS;
}

unsigned NotifyImvConnectionState( TNC_ConnectionID cid, TNC_ConnectionState state )
{
    TNC_Result rc = TNC_RESULT_SUCCESS;
    extern char *g_pszConnStates[];

    if( NULL != imvFuncs.pfnNotifyConnectionChange )
    {
        outfmt( OUT_LEVEL_NORMAL, "> TNC_IMV_NotifyConnectionChange (IMV: %d, CID: %d, state: `%s')\n", 
            IMV_ID, cid, g_pszConnStates[ state ] );

        rc = imvFuncs.pfnNotifyConnectionChange( IMV_ID, cid, state );
        outfmt( OUT_LEVEL_NORMAL, "> TNC_IMV_NotifyConnectionChange result: %d\n", rc );
    }

    return rc;
}

static int
subevalvar_misc(char *p, const char *var, int subtype, int startloc,
  int varflags)
{
	char *startp;
	struct nodelist *saveargbackq = argbackq;
	int amount;

	argstr(p, EXP_TILDE, NULL);
	STACKSTRNUL(expdest);
	argbackq = saveargbackq;
	startp = stackblock() + startloc;

	switch (subtype) {
	case VSASSIGN:
		setvar(var, startp, 0);
		amount = startp - expdest;
		STADJUST(amount, expdest);
		return 1;

	case VSQUESTION:
		if (*p != CTLENDVAR) {
			outfmt(out2, "%s\n", startp);
			error((char *)NULL);
		}
		error("%.*s: parameter %snot set", (int)(p - var - 1),
		      var, (varflags & VSNUL) ? "null or " : "");
		return 0;

	default:
		abort();
	}
}

std::vector<std::basic_string<charT> >
gather_month_strings(const std::locale& locale, bool short_strings=true)
{
  typedef std::basic_string<charT> string_type;
  typedef std::vector<string_type> collection_type;
  typedef std::basic_ostringstream<charT> ostream_type;
  typedef std::ostreambuf_iterator<charT> ostream_iter_type;
  typedef std::basic_ostringstream<charT> stringstream_type;
  typedef std::time_put<charT>           time_put_facet_type;
  charT short_fmt[3] = { '%', 'b' };
  charT long_fmt[3]  = { '%', 'B' };
  collection_type months;
  string_type outfmt(short_fmt);
  if (!short_strings) {
    outfmt = long_fmt;
  }
  {
    //grab the needed strings by using the locale to
    //output each month
    for (int m=0; m < 12; m++) {
      tm tm_value;
      tm_value.tm_mon = m;
      stringstream_type ss;
      ostream_iter_type oitr(ss);
      std::use_facet<time_put_facet_type>(locale).put(oitr, ss, ss.fill(),
                                                      &tm_value,
                                                      &*outfmt.begin(),
                                                      &*outfmt.begin()+outfmt.size());
      months.push_back(ss.str());
    }
  }
  return months;
}

/*
 * TODO - sort output
 */
int
aliascmd(int argc, char **argv)
{
	char *n, *v;
	int ret = 0;
	struct alias *ap;

	if (argc == 1) {
		int i;

		for (i = 0; i < ATABSIZE; i++)
			for (ap = atab[i]; ap; ap = ap->next) {
				printalias(ap);
			}
		return (0);
	}
	while ((n = *++argv) != NULL) {
		if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
			if ((ap = *__lookupalias(n)) == NULL) {
				outfmt(out2, "%s: %s not found\n", "alias", n);
				ret = 1;
			} else
				printalias(ap);
		} else {
			*v++ = '\0';
			setalias(n, v);
		}
	}

	return (ret);
}

int
aliascmd(int argc, char **argv)
{
	char *n, *v;
	int ret = 0;
	struct alias *ap;

	if (argc == 1) {
		printaliases();
		return (0);
	}
	while ((n = *++argv) != NULL) {
		if ((v = strchr(n+1, '=')) == NULL) /* n+1: funny ksh stuff */
			if ((ap = lookupalias(n, 0)) == NULL) {
				outfmt(out2, "alias: %s not found\n", n);
				ret = 1;
			} else
				printalias(ap);
		else {
			*v++ = '\0';
			setalias(n, v);
		}
	}

	return (ret);
}

void
chkmail(void)
{
	const char *mpath;
	char *p;
	char *q;
	time_t *mtp;
	struct stackmark smark;
#ifdef WINDOWS
	struct stat statb;
#else
	struct stat64 statb;
#endif

	setstackmark(&smark);
	mpath = mpathset() ? mpathval() : mailval();
	for (mtp = mailtime; mtp < mailtime + MAXMBOXES; mtp++) {
		p = padvance(&mpath, nullstr);
		if (p == NULL)
			break;
		if (*p == '\0')
			continue;
		for (q = p ; *q ; q++);
#ifdef DEBUG
		if (q[-1] != '/')
			abort();
#endif
		q[-1] = '\0';			/* delete trailing '/' */
#ifdef WINDOWS
		if (stat(p, &statb) < 0) {
#else
		if (stat64(p, &statb) < 0) {
#endif
			*mtp = 0;
			continue;
		}
		if (!changed && statb.st_mtime != *mtp) {
			outfmt(
				&errout, snlfmt,
				pathopt ? pathopt : "you have mail"
			);
		}
		*mtp = statb.st_mtime;
	}
	changed = 0;
	popstackmark(&smark);
}


void
changemail(const char *val)
{
	changed++;
}

String *jnl_readprompt (const char *prompt)

{
  char *buff, header[16], *p;
  String *string;
  uLong strln;

  /* If recovery file open, read from it, otherwise read from terminal */

  if (recover_file == NULL) goto readterminal;
  if (fgets (header, sizeof header, recover_file) == NULL) goto closerecovery;
  if (header[0] != '*') goto badrecovery;
  if (strcmp (header + 1, "EOF\n") == 0) {
    string = NULL;
    goto writejournal;
  }
  strln = strtoul (header + 1, &p, 10);
  if (*p != '\n') goto badrecovery;
  buff = malloc (strln + 1);
  if (fread (buff, strln, 1, recover_file) == 0) goto closerecovery;
  string = string_create (strln, buff);
  buff[strln] = 0;
  outfmt (strlen (prompt) + strlen (buff), "%s%s\n", prompt, buff);
  free (buff);
  goto writejournal;

badrecovery:
  outerr (strlen (header), "bad recovery file format at %s\n", header);
closerecovery:
  fclose (recover_file);
  recover_file = NULL;

  /* Read from terminal screen after flushing any output */

readterminal:
  output ();
  string = os_readprompt (prompt);

  /* Write journal record */

writejournal:
  if (journal_file != NULL) {
    if (string == NULL) fprintf (journal_file, "*EOF\n");
    else {
      strln = string_getlen (string);
      fprintf (journal_file, "*%u\n", strln);
      fwrite (string_getval (string), strln, 1, journal_file);
    }
  }

  /* Return pointer to string (NULL for eof) */

  return (string);
}

TNC_Result TNC_TNCS_SendMessageSOH(
/*in*/  TNC_IMVID imvID,
/*in*/  TNC_ConnectionID connectionID,
/*in*/  TNC_BufferReference sohReportEntry,
/*in*/  TNC_UInt32 sohRELength)
{
	MESSAGE_SOH  sohMessage;

    outfmt( OUT_LEVEL_NORMAL, "< TNC_TNCS_SendMessageSOH: IMV %d, CID %d, msg length %d\n", 
        imvID, connectionID, sohRELength );

    outfmt( OUT_LEVEL_VERBOSE, "< IMV message data:\n" );
    outmessage( OUT_LEVEL_VERBOSE, sohReportEntry, sohRELength );

	sohMessage.sohReportEntry = sohReportEntry;
	sohMessage.sohRELength = sohRELength;

    QueueAddMessageSOH( &sohMessage );

    return TNC_RESULT_SUCCESS;
}

void cmd_delete (char *cp)

{

  first = 1;
  count = 0;
  if (range_multiple (cp, &cp, delete_range, &first) >= 0) eoltest (cp);
  if (count == 0) outerr (0, "no lines deleted\n");
  else outerr (12, "%u line%s deleted\n", count, (count == 1) ? "" : "s");
  if (cur_position.line != NULL) line_print (cur_position.line);
  else outfmt (strlen (buffer_name (cur_position.buffer)), "[EOB=%s]\n", buffer_name (cur_position.buffer));
}

int
trapcmd(int argc, char **argv)
{
    char *action;
    char **ap;
    int signo;

    nextopt(nullstr);
    ap = argptr;
    if (!*ap) {
        for (signo = 0 ; signo < NSIG ; signo++) {
            if (trap[signo] != NULL) {
                out1fmt(
                    "trap -- %s %s\n",
                    single_quote(trap[signo]),
                    signal_names[signo]
                );
            }
        }
        return 0;
    }
    if (!ap[1])
        action = NULL;
    else
        action = *ap++;
    while (*ap) {
        if ((signo = decode_signal(*ap, 0)) < 0) {
            outfmt(out2, "trap: %s: bad trap\n", *ap);
            return 1;
        }
        INTOFF;
        if (action) {
            if (action[0] == '-' && action[1] == '\0')
                action = NULL;
            else {
                if (*action)
                    trapcnt++;
                action = savestr(action);
            }
        }
        if (trap[signo]) {
            if (*trap[signo])
                trapcnt--;
            ckfree(trap[signo]);
        }
        trap[signo] = action;
        if (signo != 0)
            setsignal(signo);
        INTON;
        ap++;
    }
    return 0;
}

static void exvwarning2(const char *msg, va_list ap)
{
	struct output *errs;
	const char *name;
	const char *fmt;

	errs = out2;
	name = arg0 ? arg0 : "sh";
	fmt = "%s: %d: ";
	outfmt(errs, fmt, name, errlinno);
	doformat(errs, msg, ap);
	outc('\n', errs);
}

void TerminateIMV(void)
{
    TNC_Result result;

    if( NULL != imvFuncs.pfnTerminate )
    {
        outfmt( OUT_LEVEL_NORMAL, "> TNC_IMV_Terminate (IMV %d)\n", IMV_ID );
        result = imvFuncs.pfnTerminate( IMV_ID );
        outfmt( OUT_LEVEL_NORMAL, "> TNC_IMV_Terminate result: %d\n", result );
    }

    free( g_pImvMessageTypes );
    g_pImvMessageTypes = NULL;
    g_nImvMessageTypesCount = 0;

	free( g_pImvMessageLongSubtypes );
	free( g_pImvVendorIDs );
	g_pImvMessageLongSubtypes = NULL;
	g_pImvVendorIDs = NULL;
	g_nImvMessageLongSubtypesCount = 0;

    UnloadImvDLL();
}