text:
ALTER TABLE m_task ADD (
  wfEndTimestamp           TIMESTAMP,
  wfObjectRef_relation     VARCHAR2(157 CHAR),
  wfObjectRef_targetOid    VARCHAR2(36 CHAR),
  wfObjectRef_type         NUMBER(10, 0),
  wfProcessInstanceId      VARCHAR2(255 CHAR),
  wfRequesterRef_relation  VARCHAR2(157 CHAR),
  wfRequesterRef_targetOid VARCHAR2(36 CHAR),
  wfRequesterRef_type      NUMBER(10, 0),
  wfStartTimestamp         TIMESTAMP,
  wfTargetRef_relation     VARCHAR2(157 CHAR),
  wfTargetRef_targetOid    VARCHAR2(36 CHAR),
  wfTargetRef_type         NUMBER(10, 0)
);

CREATE INDEX iTaskWfProcessInstanceId ON m_task (wfProcessInstanceId) INITRANS 30;

CREATE INDEX iTaskWfStartTimestamp ON m_task (wfStartTimestamp) INITRANS 30;

CREATE INDEX iTaskWfEndTimestamp ON m_task (wfEndTimestamp) INITRANS 30;

CREATE INDEX iTaskWfRequesterOid ON m_task (wfRequesterRef_targetOid) INITRANS 30;

CREATE INDEX iTaskWfObjectOid ON m_task (wfObjectRef_targetOid) INITRANS 30;

CREATE INDEX iTaskWfTargetOid ON m_task (wfTargetRef_targetOid) INITRANS 30;


text:
{{ entry.title }}

Sass file: {{ entry.scss }}

      {{ entry.content }}

      {% highlight html %}{{ entry.content }}{% endhighlight %}

redpajama_set_name: RedPajamaGithub


text:
/*
 * DO NOT EDIT.  THIS FILE IS GENERATED FROM /builds/slave/rel-m-rel-xr-osx64-bld/build/netwerk/base/public/nsIResumableChannel.idl
 */

#ifndef __gen_nsIResumableChannel_h__
#define __gen_nsIResumableChannel_h__

#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif

/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
class nsIStreamListener; /* forward declaration */

/* starting interface:    nsIResumableChannel */
#define NS_IRESUMABLECHANNEL_IID_STR "4ad136fa-83af-4a22-a76e-503642c0f4a8"

#define NS_IRESUMABLECHANNEL_IID \
  {0x4ad136fa, 0x83af, 0x4a22, \
    { 0xa7, 0x6e, 0x50, 0x36, 0x42, 0xc0, 0xf4, 0xa8 }}

class NS_NO_VTABLE NS_SCRIPTABLE nsIResumableChannel : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IRESUMABLECHANNEL_IID)

  /* void resumeAt (in unsigned long long startPos, in ACString entityID); */
  NS_SCRIPTABLE NS_IMETHOD ResumeAt(PRUint64 startPos, const nsACString & entityID) = 0;

  /* readonly attribute ACString entityID; */
  NS_SCRIPTABLE NS_IMETHOD GetEntityID(nsACString & aEntityID) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIResumableChannel, NS_IRESUMABLECHANNEL_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIRESUMABLECHANNEL \
  NS_SCRIPTABLE NS_IMETHOD ResumeAt(PRUint64 startPos, const nsACString & entityID); \
  NS_SCRIPTABLE NS_IMETHOD GetEntityID(nsACString & aEntityID);

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIRESUMABLECHANNEL(_to) \
  NS_SCRIPTABLE NS_IMETHOD ResumeAt(PRUint64 startPos, const nsACString & entityID) { return _to ResumeAt(startPos, entityID); } \
  NS_SCRIPTABLE NS_IMETHOD GetEntityID(nsACString & aEntityID) { return _to GetEntityID(aEntityID); }

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIRESUMABLECHANNEL(_to) \
  NS_SCRIPTABLE NS_IMETHOD ResumeAt(PRUint64 startPos, const nsACString & entityID) { return !_to ? NS_ERROR_NULL_POINTER : _to->ResumeAt(startPos, entityID); } \
  NS_SCRIPTABLE NS_IMETHOD GetEntityID(nsACString & aEntityID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetEntityID(aEntityID); }

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsResumableChannel : public nsIResumableChannel
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIRESUMABLECHANNEL

  nsResumableChannel();

private:
  ~nsResumableChannel();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsResumableChannel, nsIResumableChannel)

nsResumableChannel::nsResumableChannel()
{
  /* member initializers and constructor code */
}

nsResumableChannel::~nsResumableChannel()
{
  /* destructor code */
}

/* void resumeAt (in unsigned long long startPos, in ACString entityID); */
NS_IMETHODIMP nsResumableChannel::ResumeAt(PRUint64 startPos, const nsACString & entityID)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute ACString entityID; */
NS_IMETHODIMP nsResumableChannel::GetEntityID(nsACString & aEntityID)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif

#endif /* __gen_nsIResumableChannel_h__ */


text:
<?php

# prisijungiam prie DB

require("inc/mysql_conn.php");

# norimo laikotarpio pasirinkimas

$chart_days = $_GET["type"];

# anksciau naudotas budas --> taip sakant, legacy

# gaunam paskutines reiksmes surusiuotas didejimo tvarka pagal id

# norim 192 eiluciu, nes 4*24*2=192, o tai yra 2 paros duomenu kas 15 min.

# $query = "SELECT  * FROM (SELECT * FROM banana ORDER BY id DESC LIMIT 192)x ORDER BY id";

# pradedant 1 savaites grafiku duomenis reikia suvidurkinti

switch ($chart_days) {

// 1 diena

  case '1d':

	$query = "SELECT 1*FLOOR(id/1) as id, data, avg(temp01) as temp01,

  avg(temp02) as temp02 FROM (SELECT * FROM banana where data > NOW() - INTERVAL 1 DAY order by id)x

  group by 1*FLOOR(id/1)";

	break;

// 1 savaite

  case '1s':

	$query = "SELECT 4*FLOOR(id/4) as id, data, avg(temp01) as temp01,

  avg(temp02) as temp02 FROM (SELECT * FROM banana where data > NOW() - INTERVAL 1 WEEK order by id)x

  group by 4*FLOOR(id/4)";

	break;

// 2 savaites

  case '2s':

	$query = "SELECT 8*FLOOR(id/8) as id, data, avg(temp01) as temp01,

  avg(temp02) as temp02 FROM (SELECT * FROM banana where data > NOW() - INTERVAL 2 WEEK order by id)x

  group by 8*FLOOR(id/8)";

	break;

// 1 menuo

  case '1m':

	$query = "SELECT 16*FLOOR(id/16) as id, data, avg(temp01) as temp01,

  avg(temp02) as temp02 FROM (SELECT * FROM banana where data > NOW() - INTERVAL 1 MONTH order by id)x

  group by 16*FLOOR(id/16)";

	break;

// visais kitais atvejais dvi dienos

  default:

	$query = "SELECT 1*FLOOR(id/1) as id, data, avg(temp01) as temp01,

  avg(temp02) as temp02 FROM (SELECT * FROM banana where data > NOW() - INTERVAL 2 DAY order by id)x

  group by 1*FLOOR(id/1)";

	$chart_days = "2d";

}

# kreipiames i DB su norima uzklausa

$result = mysql_query($query) or die(mysql_error());

# sukuriam masyva su lietuviskas menesiu pavadinimais X asiai

# taip pat multi masyva su pirmo daviklio duomenim ir tikslia data tooltip'ui

$real_min=100;

$real_max=-100;

while($row = mysql_fetch_array($result)){

setlocale(LC_TIME, 'lt_LT'); # lietuviski menesiu pavadinimai

$temper['label'][]=strftime("%b-%d %H:%M", strtotime($row['data']));

$temper['temp01'][$row['data']][]=$row['temp01'];

$temper['temp02'][$row['data']][]=$row['temp02'];

# surandam min ir maks reiksmes Y asies reziams nustatyti

if ($row['temp01'] < $row['temp02']) {

  $min = $row['temp01'];

}

else {

  $min = $row['temp02'];

}

if ($row['temp01'] > $row['temp02']) {

  $max = $row['temp01'];

}

else {

  $max = $row['temp02'];

}

if ($min < $real_min) {

 $real_min = $min;

}

if ($max > $real_max) {

 $real_max = $max;

}

}

# galutiniai Y asies intervalo reziai (pvz. 15,1 ir 24,3 ===> 15 ir 25)

$y_min = floor($real_min);

$y_max = ceil($real_max);

?>

<!DOCTYPE html>

<link href="css/chartist.min.css" rel="stylesheet" type="text/css" />

<link href="css/main.css" rel="stylesheet" type="text/css" />

<link type="text/css" rel="stylesheet" href="lib-mbox/style.css" />

<meta charset="utf-8" />

<meta name="robots" content="noindex" />

<meta http-equiv="Cache-Control" content="no-store" />

<title>Home-Monitor Web Interface</title>

This page is intented to be viewed on a computer screen!

In order to see see the content please maximize your browser window.

  <a href="?type=1d" <?php; if ($chart_days == "1d") {print('class="active"');} ?>>1_diena |

  <a href="./" <?php; if ($chart_days == "2d") {print('class="active"');} ?>>2_dienos |

  <a href="?type=1s" <?php; if ($chart_days == "1s") {print('class="active"');} ?>>1_savaitė |

  <a href="?type=2s" <?php; if ($chart_days == "2s") {print('class="active"');} ?>>2_savaitės |

  <a href="?type=1m" <?php; if ($chart_days == "1m") {print('class="active"');} ?>>1_mėnuo

  informacija |

  kameros |

  video

bananapi@malūno81:~/ health of Banana Pi?

<?php; echo file_get_contents("../ip.txt" );?>

bananapi@malūno81:~/ network check?

<?php; echo file_get_contents("../ping.txt" );?>


text:
                <button type="button" class="close" data-dismiss="modal" ng-disabled="saveInProgress" aria-hidden="true">×</button>

Edit: {{dashboard.name}}

                    <input type="text" class="form-control" placeholder="Dashboard Name" ng-model="dashboard.name">

                <button type="button" class="btn btn-default" ng-disabled="saveInProgress" data-dismiss="modal">Close</button>
                <button type="button" class="btn btn-primary" ng-disabled="saveInProgress" ng-click="saveDashboard()">Save</button>


text:
/* $OpenBSD: readconf.c,v 1.218 2014/02/23 20:11:36 djm Exp $ */
/* $FreeBSD$ */
/*
 * Author: Tatu Ylonen <ylo@cs.hut.fi>
 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
 *                    All rights reserved
 * Functions for reading the configuration files.
 *
 * As far as I am concerned, the code I have written for this software
 * can be used freely for any purpose.  Any derived versions of this
 * software must be clearly marked as such, and if the derived work is
 * incompatible with the protocol description in the RFC file, it must be
 * called by a name other than "ssh" or "Secure Shell".
 */

#include "includes.h"
__RCSID("$FreeBSD$");

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/wait.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#ifdef HAVE_PATHS_H
# include <paths.h>
#endif
#include <pwd.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#ifdef HAVE_UTIL_H
#include <util.h>
#endif

#include "xmalloc.h"
#include "ssh.h"
#include "compat.h"
#include "cipher.h"
#include "pathnames.h"
#include "log.h"
#include "key.h"
#include "readconf.h"
#include "match.h"
#include "misc.h"
#include "buffer.h"
#include "kex.h"
#include "mac.h"
#include "uidswap.h"
#include "version.h"

/* Format of the configuration file:

   # Configuration data is parsed as follows:
   #  1. command line options
   #  2. user-specific file
   #  3. system-wide file
   # Any configuration value is only changed the first time it is set.
   # Thus, host-specific definitions should be at the beginning of the
   # configuration file, and defaults at the end.

   # Host-specific declarations.  These may override anything above.  A single
   # host may match multiple declarations; these are processed in the order
   # that they are given in.

   Host *.ngs.fi ngs.fi
     User foo

   Host fake.com
     HostName another.host.name.real.org
     User blaah
     Port 34289
     ForwardX11 no
     ForwardAgent no

   Host books.com
     RemoteForward 9999 shadows.cs.hut.fi:9999
     Cipher 3des

   Host fascist.blob.com
     Port 23123
     User tylonen
     PasswordAuthentication no

   Host puukko.hut.fi
     User t35124p
     ProxyCommand ssh-proxy %h %p

   Host *.fr
     PublicKeyAuthentication no

   Host *.su
     Cipher none
     PasswordAuthentication no

   Host vpn.fake.com
     Tunnel yes
     TunnelDevice 3

   # Defaults for various options
   Host *
     ForwardAgent no
     ForwardX11 no
     PasswordAuthentication yes
     RSAAuthentication yes
     RhostsRSAAuthentication yes
     StrictHostKeyChecking yes
     TcpKeepAlive no
     IdentityFile ~/.ssh/identity
     Port 22
     EscapeChar ~

*/

/* Keyword tokens. */

typedef enum {
	oBadOption,
	oHost, oMatch,
	oForwardAgent, oForwardX11, oForwardX11Trusted, oForwardX11Timeout,
	oGatewayPorts, oExitOnForwardFailure,
	oPasswordAuthentication, oRSAAuthentication,
	oChallengeResponseAuthentication, oXAuthLocation,
	oIdentityFile, oHostName, oPort, oCipher, oRemoteForward, oLocalForward,
	oUser, oEscapeChar, oRhostsRSAAuthentication, oProxyCommand,
	oGlobalKnownHostsFile, oUserKnownHostsFile, oConnectionAttempts,
	oBatchMode, oCheckHostIP, oStrictHostKeyChecking, oCompression,
	oCompressionLevel, oTCPKeepAlive, oNumberOfPasswordPrompts,
	oUsePrivilegedPort, oLogLevel, oCiphers, oProtocol, oMacs,
	oGlobalKnownHostsFile2, oUserKnownHostsFile2, oPubkeyAuthentication,
	oKbdInteractiveAuthentication, oKbdInteractiveDevices, oHostKeyAlias,
	oDynamicForward, oPreferredAuthentications, oHostbasedAuthentication,
	oHostKeyAlgorithms, oBindAddress, oPKCS11Provider,
	oClearAllForwardings, oNoHostAuthenticationForLocalhost,
	oEnableSSHKeysign, oRekeyLimit, oVerifyHostKeyDNS, oConnectTimeout,
	oAddressFamily, oGssAuthentication, oGssDelegateCreds,
	oServerAliveInterval, oServerAliveCountMax, oIdentitiesOnly,
	oSendEnv, oControlPath, oControlMaster, oControlPersist,
	oHashKnownHosts,
	oTunnel, oTunnelDevice, oLocalCommand, oPermitLocalCommand,
	oVisualHostKey, oUseRoaming,
	oKexAlgorithms, oIPQoS, oRequestTTY, oIgnoreUnknown, oProxyUseFdpass,
	oCanonicalDomains, oCanonicalizeHostname, oCanonicalizeMaxDots,
	oCanonicalizeFallbackLocal, oCanonicalizePermittedCNAMEs,
	oIgnoredUnknownOption,
	oHPNDisabled, oHPNBufferSize, oTcpRcvBufPoll, oTcpRcvBuf,
#ifdef NONE_CIPHER_ENABLED
	oNoneEnabled, oNoneSwitch,
#endif
	oVersionAddendum, oDeprecated, oUnsupported
} OpCodes;

/* Textual representations of the tokens. */

static struct {
	const char *name;
	OpCodes opcode;
} keywords[] = {
	{ "forwardagent", oForwardAgent },
	{ "forwardx11", oForwardX11 },
	{ "forwardx11trusted", oForwardX11Trusted },
	{ "forwardx11timeout", oForwardX11Timeout },
	{ "exitonforwardfailure", oExitOnForwardFailure },
	{ "xauthlocation", oXAuthLocation },
	{ "gatewayports", oGatewayPorts },
	{ "useprivilegedport", oUsePrivilegedPort },
	{ "rhostsauthentication", oDeprecated },
	{ "passwordauthentication", oPasswordAuthentication },
	{ "kbdinteractiveauthentication", oKbdInteractiveAuthentication },
	{ "kbdinteractivedevices", oKbdInteractiveDevices },
	{ "rsaauthentication", oRSAAuthentication },
	{ "pubkeyauthentication", oPubkeyAuthentication },
	{ "dsaauthentication", oPubkeyAuthentication },		    /* alias */
	{ "rhostsrsaauthentication", oRhostsRSAAuthentication },
	{ "hostbasedauthentication", oHostbasedAuthentication },
	{ "challengeresponseauthentication", oChallengeResponseAuthentication },
	{ "skeyauthentication", oChallengeResponseAuthentication }, /* alias */
	{ "tisauthentication", oChallengeResponseAuthentication },  /* alias */
	{ "kerberosauthentication", oUnsupported },
	{ "kerberostgtpassing", oUnsupported },
	{ "afstokenpassing", oUnsupported },
#if defined(GSSAPI)
	{ "gssapiauthentication", oGssAuthentication },
	{ "gssapidelegatecredentials", oGssDelegateCreds },
#else
	{ "gssapiauthentication", oUnsupported },
	{ "gssapidelegatecredentials", oUnsupported },
#endif
	{ "fallbacktorsh", oDeprecated },
	{ "usersh", oDeprecated },
	{ "identityfile", oIdentityFile },
	{ "identityfile2", oIdentityFile },			/* obsolete */
	{ "identitiesonly", oIdentitiesOnly },
	{ "hostname", oHostName },
	{ "hostkeyalias", oHostKeyAlias },
	{ "proxycommand", oProxyCommand },
	{ "port", oPort },
	{ "cipher", oCipher },
	{ "ciphers", oCiphers },
	{ "macs", oMacs },
	{ "protocol", oProtocol },
	{ "remoteforward", oRemoteForward },
	{ "localforward", oLocalForward },
	{ "user", oUser },
	{ "host", oHost },
	{ "match", oMatch },
	{ "escapechar", oEscapeChar },
	{ "globalknownhostsfile", oGlobalKnownHostsFile },
	{ "globalknownhostsfile2", oDeprecated },
	{ "userknownhostsfile", oUserKnownHostsFile },
	{ "userknownhostsfile2", oDeprecated },
	{ "connectionattempts", oConnectionAttempts },
	{ "batchmode", oBatchMode },
	{ "checkhostip", oCheckHostIP },
	{ "stricthostkeychecking", oStrictHostKeyChecking },
	{ "compression", oCompression },
	{ "compressionlevel", oCompressionLevel },
	{ "tcpkeepalive", oTCPKeepAlive },
	{ "keepalive", oTCPKeepAlive },				/* obsolete */
	{ "numberofpasswordprompts", oNumberOfPasswordPrompts },
	{ "loglevel", oLogLevel },
	{ "dynamicforward", oDynamicForward },
	{ "preferredauthentications", oPreferredAuthentications },
	{ "hostkeyalgorithms", oHostKeyAlgorithms },
	{ "bindaddress", oBindAddress },
#ifdef ENABLE_PKCS11
	{ "smartcarddevice", oPKCS11Provider },
	{ "pkcs11provider", oPKCS11Provider },
#else
	{ "smartcarddevice", oUnsupported },
	{ "pkcs11provider", oUnsupported },
#endif
	{ "clearallforwardings", oClearAllForwardings },
	{ "enablesshkeysign", oEnableSSHKeysign },
	{ "verifyhostkeydns", oVerifyHostKeyDNS },
	{ "nohostauthenticationforlocalhost", oNoHostAuthenticationForLocalhost },
	{ "rekeylimit", oRekeyLimit },
	{ "connecttimeout", oConnectTimeout },
	{ "addressfamily", oAddressFamily },
	{ "serveraliveinterval", oServerAliveInterval },
	{ "serveralivecountmax", oServerAliveCountMax },
	{ "sendenv", oSendEnv },
	{ "controlpath", oControlPath },
	{ "controlmaster", oControlMaster },
	{ "controlpersist", oControlPersist },
	{ "hashknownhosts", oHashKnownHosts },
	{ "tunnel", oTunnel },
	{ "tunneldevice", oTunnelDevice },
	{ "localcommand", oLocalCommand },
	{ "permitlocalcommand", oPermitLocalCommand },
	{ "visualhostkey", oVisualHostKey },
	{ "useroaming", oUseRoaming },
	{ "kexalgorithms", oKexAlgorithms },
	{ "ipqos", oIPQoS },
	{ "requesttty", oRequestTTY },
	{ "proxyusefdpass", oProxyUseFdpass },
	{ "canonicaldomains", oCanonicalDomains },
	{ "canonicalizefallbacklocal", oCanonicalizeFallbackLocal },
	{ "canonicalizehostname", oCanonicalizeHostname },
	{ "canonicalizemaxdots", oCanonicalizeMaxDots },
	{ "canonicalizepermittedcnames", oCanonicalizePermittedCNAMEs },
	{ "ignoreunknown", oIgnoreUnknown },
	{ "hpndisabled", oHPNDisabled },
	{ "hpnbuffersize", oHPNBufferSize },
	{ "tcprcvbufpoll", oTcpRcvBufPoll },
	{ "tcprcvbuf", oTcpRcvBuf },
#ifdef	NONE_CIPHER_ENABLED
	{ "noneenabled", oNoneEnabled },
	{ "noneswitch", oNoneSwitch },
#endif
	{ "versionaddendum", oVersionAddendum },

	{ NULL, oBadOption }
};

/*
 * Adds a local TCP/IP port forward to options.  Never returns if there is an
 * error.
 */

void
add_local_forward(Options *options, const Forward *newfwd)
{
	Forward *fwd;
#ifndef NO_IPPORT_RESERVED_CONCEPT
	extern uid_t original_real_uid;
	int ipport_reserved;
#ifdef __FreeBSD__
	size_t len_ipport_reserved = sizeof(ipport_reserved);

	if (sysctlbyname("net.inet.ip.portrange.reservedhigh",
	    &ipport_reserved, &len_ipport_reserved, NULL, 0) != 0)
		ipport_reserved = IPPORT_RESERVED;
	else
		ipport_reserved++;
#else
	ipport_reserved = IPPORT_RESERVED;
#endif
	if (newfwd->listen_port < ipport_reserved && original_real_uid != 0)
		fatal("Privileged ports can only be forwarded by root.");
#endif
	options->local_forwards = xrealloc(options->local_forwards,
	    options->num_local_forwards + 1,
	    sizeof(*options->local_forwards));
	fwd = &options->local_forwards[options->num_local_forwards++];

	fwd->listen_host = newfwd->listen_host;
	fwd->listen_port = newfwd->listen_port;
	fwd->connect_host = newfwd->connect_host;
	fwd->connect_port = newfwd->connect_port;
}

/*
 * Adds a remote TCP/IP port forward to options.  Never returns if there is
 * an error.
 */

void
add_remote_forward(Options *options, const Forward *newfwd)
{
	Forward *fwd;

	options->remote_forwards = xrealloc(options->remote_forwards,
	    options->num_remote_forwards + 1,
	    sizeof(*options->remote_forwards));
	fwd = &options->remote_forwards[options->num_remote_forwards++];

	fwd->listen_host = newfwd->listen_host;
	fwd->listen_port = newfwd->listen_port;
	fwd->connect_host = newfwd->connect_host;
	fwd->connect_port = newfwd->connect_port;
	fwd->handle = newfwd->handle;
	fwd->allocated_port = 0;
}

static void
clear_forwardings(Options *options)
{
	int i;

	for (i = 0; i < options->num_local_forwards; i++) {
		free(options->local_forwards[i].listen_host);
		free(options->local_forwards[i].connect_host);
	}
	if (options->num_local_forwards > 0) {
		free(options->local_forwards);
		options->local_forwards = NULL;
	}
	options->num_local_forwards = 0;
	for (i = 0; i < options->num_remote_forwards; i++) {
		free(options->remote_forwards[i].listen_host);
		free(options->remote_forwards[i].connect_host);
	}
	if (options->num_remote_forwards > 0) {
		free(options->remote_forwards);
		options->remote_forwards = NULL;
	}
	options->num_remote_forwards = 0;
	options->tun_open = SSH_TUNMODE_NO;
}

void
add_identity_file(Options *options, const char *dir, const char *filename,
    int userprovided)
{
	char *path;

	if (options->num_identity_files >= SSH_MAX_IDENTITY_FILES)
		fatal("Too many identity files specified (max %d)",
		    SSH_MAX_IDENTITY_FILES);

	if (dir == NULL) /* no dir, filename is absolute */
		path = xstrdup(filename);
	else
		(void)xasprintf(&path, "%.100s%.100s", dir, filename);

	options->identity_file_userprovided[options->num_identity_files] =
	    userprovided;
	options->identity_files[options->num_identity_files++] = path;
}

int
default_ssh_port(void)
{
	static int port;
	struct servent *sp;

	if (port == 0) {
		sp = getservbyname(SSH_SERVICE_NAME, "tcp");
		port = sp ? ntohs(sp->s_port) : SSH_DEFAULT_PORT;
	}
	return port;
}

/*
 * Execute a command in a shell.
 * Return its exit status or -1 on abnormal exit.
 */
static int
execute_in_shell(const char *cmd)
{
	char *shell, *command_string;
	pid_t pid;
	int devnull, status;
	extern uid_t original_real_uid;

	if ((shell = getenv("SHELL")) == NULL)
		shell = _PATH_BSHELL;

	/*
	 * Use "exec" to avoid "sh -c" processes on some platforms
	 * (e.g. Solaris)
	 */
	xasprintf(&command_string, "exec %s", cmd);

	/* Need this to redirect subprocess stdin/out */
	if ((devnull = open(_PATH_DEVNULL, O_RDWR)) == -1)
		fatal("open(/dev/null): %s", strerror(errno));

	debug("Executing command: '%.500s'", cmd);

	/* Fork and execute the command. */
	if ((pid = fork()) == 0) {
		char *argv[4];

		/* Child.  Permanently give up superuser privileges. */
		permanently_drop_suid(original_real_uid);

		/* Redirect child stdin and stdout. Leave stderr */
		if (dup2(devnull, STDIN_FILENO) == -1)
			fatal("dup2: %s", strerror(errno));
		if (dup2(devnull, STDOUT_FILENO) == -1)
			fatal("dup2: %s", strerror(errno));
		if (devnull > STDERR_FILENO)
			close(devnull);
		closefrom(STDERR_FILENO + 1);

		argv[0] = shell;
		argv[1] = "-c";
		argv[2] = command_string;
		argv[3] = NULL;

		execv(argv[0], argv);
		error("Unable to execute '%.100s': %s", cmd, strerror(errno));
		/* Die with signal to make this error apparent to parent. */
		signal(SIGTERM, SIG_DFL);
		kill(getpid(), SIGTERM);
		_exit(1);
	}
	/* Parent. */
	if (pid < 0)
		fatal("%s: fork: %.100s", __func__, strerror(errno));

	close(devnull);
	free(command_string);

	while (waitpid(pid, &status, 0) == -1) {
		if (errno != EINTR && errno != EAGAIN)
			fatal("%s: waitpid: %s", __func__, strerror(errno));
	}
	if (!WIFEXITED(status)) {
		error("command '%.100s' exited abnormally", cmd);
		return -1;
	}
	debug3("command returned status %d", WEXITSTATUS(status));
	return WEXITSTATUS(status);
}

/*
 * Parse and execute a Match directive.
 */
static int
match_cfg_line(Options *options, char **condition, struct passwd *pw,
    const char *host_arg, const char *filename, int linenum)
{
	char *arg, *attrib, *cmd, *cp = *condition, *host;
	const char *ruser;
	int r, port, result = 1, attributes = 0;
	size_t len;
	char thishost[NI_MAXHOST], shorthost[NI_MAXHOST], portstr[NI_MAXSERV];

	/*
	 * Configuration is likely to be incomplete at this point so we
	 * must be prepared to use default values.
	 */
	port = options->port <= 0 ? default_ssh_port() : options->port;
	ruser = options->user == NULL ? pw->pw_name : options->user;
	if (options->hostname != NULL) {
		/* NB. Please keep in sync with ssh.c:main() */
		host = percent_expand(options->hostname,
		    "h", host_arg, (char *)NULL);
	} else
		host = xstrdup(host_arg);

	debug3("checking match for '%s' host %s", cp, host);
	while ((attrib = strdelim(&cp)) && *attrib != '\0') {
		attributes++;
		if (strcasecmp(attrib, "all") == 0) {
			if (attributes != 1 ||
			    ((arg = strdelim(&cp)) != NULL && *arg != '\0')) {
				error("'all' cannot be combined with other "
				    "Match attributes");
				result = -1;
				goto out;
			}
			*condition = cp;
			result = 1;
			goto out;
		}
		if ((arg = strdelim(&cp)) == NULL || *arg == '\0') {
			error("Missing Match criteria for %s", attrib);
			result = -1;
			goto out;
		}
		len = strlen(arg);
		if (strcasecmp(attrib, "host") == 0) {
			if (match_hostname(host, arg, len) != 1)
				result = 0;
			else
				debug("%.200s line %d: matched 'Host %.100s' ",
				    filename, linenum, host);
		} else if (strcasecmp(attrib, "originalhost") == 0) {
			if (match_hostname(host_arg, arg, len) != 1)
				result = 0;
			else
				debug("%.200s line %d: matched "
				    "'OriginalHost %.100s' ",
				    filename, linenum, host_arg);
		} else if (strcasecmp(attrib, "user") == 0) {
			if (match_pattern_list(ruser, arg, len, 0) != 1)
				result = 0;
			else
				debug("%.200s line %d: matched 'User %.100s' ",
				    filename, linenum, ruser);
		} else if (strcasecmp(attrib, "localuser") == 0) {
			if (match_pattern_list(pw->pw_name, arg, len, 0) != 1)
				result = 0;
			else
				debug("%.200s line %d: matched "
				    "'LocalUser %.100s' ",
				    filename, linenum, pw->pw_name);
		} else if (strcasecmp(attrib, "exec") == 0) {
			if (gethostname(thishost, sizeof(thishost)) == -1)
				fatal("gethostname: %s", strerror(errno));
			strlcpy(shorthost, thishost, sizeof(shorthost));
			shorthost[strcspn(thishost, ".")] = '\0';
			snprintf(portstr, sizeof(portstr), "%d", port);

			cmd = percent_expand(arg,
			    "L", shorthost,
			    "d", pw->pw_dir,
			    "h", host,
			    "l", thishost,
			    "n", host_arg,
			    "p", portstr,
			    "r", ruser,
			    "u", pw->pw_name,
			    (char *)NULL);
			if (result != 1) {
				/* skip execution if prior predicate failed */
				debug("%.200s line %d: skipped exec \"%.100s\"",
				    filename, linenum, cmd);
			} else {
				r = execute_in_shell(cmd);
				if (r == -1) {
					fatal("%.200s line %d: match exec "
					    "'%.100s' error", filename,
					    linenum, cmd);
				} else if (r == 0) {
					debug("%.200s line %d: matched "
					    "'exec \"%.100s\"'", filename,
					    linenum, cmd);
				} else {
					debug("%.200s line %d: no match "
					    "'exec \"%.100s\"'", filename,
					    linenum, cmd);
					result = 0;
				}
			}
			free(cmd);
		} else {
			error("Unsupported Match attribute %s", attrib);
			result = -1;
			goto out;
		}
	}
	if (attributes == 0) {
		error("One or more attributes required for Match");
		result = -1;
		goto out;
	}
	debug3("match %sfound", result ? "" : "not ");
	*condition = cp;
 out:
	free(host);
	return result;
}

/* Check and prepare a domain name: removes trailing '.' and lowercases */
static void
valid_domain(char *name, const char *filename, int linenum)
{
	size_t i, l = strlen(name);
	u_char c, last = '\0';

	if (l == 0)
		fatal("%s line %d: empty hostname suffix", filename, linenum);
	if (!isalpha((u_char)name[0]) && !isdigit((u_char)name[0]))
		fatal("%s line %d: hostname suffix \"%.100s\" "
		    "starts with invalid character", filename, linenum, name);
	for (i = 0; i < l; i++) {
		c = tolower((u_char)name[i]);
		name[i] = (char)c;
		if (last == '.' && c == '.')
			fatal("%s line %d: hostname suffix \"%.100s\" contains "
			    "consecutive separators", filename, linenum, name);
		if (c != '.' && c != '-' && !isalnum(c) &&
		    c != '_') /* technically invalid, but common */
			fatal("%s line %d: hostname suffix \"%.100s\" contains "
			    "invalid characters", filename, linenum, name);
		last = c;
	}
	if (name[l - 1] == '.')
		name[l - 1] = '\0';
}

/*
 * Returns the number of the token pointed to by cp or oBadOption.
 */
static OpCodes
parse_token(const char *cp, const char *filename, int linenum,
    const char *ignored_unknown)
{
	int i;

	for (i = 0; keywords[i].name; i++)
		if (strcmp(cp, keywords[i].name) == 0)
			return keywords[i].opcode;
	if (ignored_unknown != NULL && match_pattern_list(cp, ignored_unknown,
	    strlen(ignored_unknown), 1) == 1)
		return oIgnoredUnknownOption;
	error("%s: line %d: Bad configuration option: %s",
	    filename, linenum, cp);
	return oBadOption;
}

/* Multistate option parsing */
struct multistate {
	char *key;
	int value;
};
static const struct multistate multistate_flag[] = {
	{ "true",			1 },
	{ "false",			0 },
	{ "yes",			1 },
	{ "no",				0 },
	{ NULL, -1 }
};
static const struct multistate multistate_yesnoask[] = {
	{ "true",			1 },
	{ "false",			0 },
	{ "yes",			1 },
	{ "no",				0 },
	{ "ask",			2 },
	{ NULL, -1 }
};
static const struct multistate multistate_addressfamily[] = {
	{ "inet",			AF_INET },
	{ "inet6",			AF_INET6 },
	{ "any",			AF_UNSPEC },
	{ NULL, -1 }
};
static const struct multistate multistate_controlmaster[] = {
	{ "true",			SSHCTL_MASTER_YES },
	{ "yes",			SSHCTL_MASTER_YES },
	{ "false",			SSHCTL_MASTER_NO },
	{ "no",				SSHCTL_MASTER_NO },
	{ "auto",			SSHCTL_MASTER_AUTO },
	{ "ask",			SSHCTL_MASTER_ASK },
	{ "autoask",			SSHCTL_MASTER_AUTO_ASK },
	{ NULL, -1 }
};
static const struct multistate multistate_tunnel[] = {
	{ "ethernet",			SSH_TUNMODE_ETHERNET },
	{ "point-to-point",		SSH_TUNMODE_POINTOPOINT },
	{ "true",			SSH_TUNMODE_DEFAULT },
	{ "yes",			SSH_TUNMODE_DEFAULT },
	{ "false",			SSH_TUNMODE_NO },
	{ "no",				SSH_TUNMODE_NO },
	{ NULL, -1 }
};
static const struct multistate multistate_requesttty[] = {
	{ "true",			REQUEST_TTY_YES },
	{ "yes",			REQUEST_TTY_YES },
	{ "false",			REQUEST_TTY_NO },
	{ "no",				REQUEST_TTY_NO },
	{ "force",			REQUEST_TTY_FORCE },
	{ "auto",			REQUEST_TTY_AUTO },
	{ NULL, -1 }
};
static const struct multistate multistate_canonicalizehostname[] = {
	{ "true",			SSH_CANONICALISE_YES },
	{ "false",			SSH_CANONICALISE_NO },
	{ "yes",			SSH_CANONICALISE_YES },
	{ "no",				SSH_CANONICALISE_NO },
	{ "always",			SSH_CANONICALISE_ALWAYS },
	{ NULL, -1 }
};

/*
 * Processes a single option line as used in the configuration files. This
 * only sets those values that have not already been set.
 */
#define WHITESPACE " \t\r\n"
int
process_config_line(Options *options, struct passwd *pw, const char *host,
    char *line, const char *filename, int linenum, int *activep, int userconfig)
{
	char *s, **charptr, *endofnumber, *keyword, *arg, *arg2;
	char **cpptr, fwdarg[256];
	u_int i, *uintptr, max_entries = 0;
	int negated, opcode, *intptr, value, value2, cmdline = 0;
	LogLevel *log_level_ptr;
	long long val64;
	size_t len;
	Forward fwd;
	const struct multistate *multistate_ptr;
	struct allowed_cname *cname;

	if (activep == NULL) { /* We are processing a command line directive */
		cmdline = 1;
		activep = &cmdline;
	}

	/* Strip trailing whitespace */
	for (len = strlen(line) - 1; len > 0; len--) {
		if (strchr(WHITESPACE, line[len]) == NULL)
			break;
		line[len] = '\0';
	}

	s = line;
	/* Get the keyword. (Each line is supposed to begin with a keyword). */
	if ((keyword = strdelim(&s)) == NULL)
		return 0;
	/* Ignore leading whitespace. */
	if (*keyword == '\0')
		keyword = strdelim(&s);
	if (keyword == NULL || !*keyword || *keyword == '\n' || *keyword == '#')
		return 0;
	/* Match lowercase keyword */
	lowercase(keyword);

	opcode = parse_token(keyword, filename, linenum,
	    options->ignored_unknown);

	switch (opcode) {
	case oBadOption:
		/* don't panic, but count bad options */
		return -1;
		/* NOTREACHED */
	case oIgnoredUnknownOption:
		debug("%s line %d: Ignored unknown option \"%s\"",
		    filename, linenum, keyword);
		return 0;
	case oConnectTimeout:
		intptr = &options->connection_timeout;
parse_time:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%s line %d: missing time value.",
			    filename, linenum);
		if ((value = convtime(arg)) == -1)
			fatal("%s line %d: invalid time value.",
			    filename, linenum);
		if (*activep && *intptr == -1)
			*intptr = value;
		break;

	case oForwardAgent:
		intptr = &options->forward_agent;
 parse_flag:
		multistate_ptr = multistate_flag;
 parse_multistate:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%s line %d: missing argument.",
			    filename, linenum);
		value = -1;
		for (i = 0; multistate_ptr[i].key != NULL; i++) {
			if (strcasecmp(arg, multistate_ptr[i].key) == 0) {
				value = multistate_ptr[i].value;
				break;
			}
		}
		if (value == -1)
			fatal("%s line %d: unsupported option \"%s\".",
			    filename, linenum, arg);
		if (*activep && *intptr == -1)
			*intptr = value;
		break;

	case oForwardX11:
		intptr = &options->forward_x11;
		goto parse_flag;

	case oForwardX11Trusted:
		intptr = &options->forward_x11_trusted;
		goto parse_flag;

	case oForwardX11Timeout:
		intptr = &options->forward_x11_timeout;
		goto parse_time;

	case oGatewayPorts:
		intptr = &options->gateway_ports;
		goto parse_flag;

	case oExitOnForwardFailure:
		intptr = &options->exit_on_forward_failure;
		goto parse_flag;

	case oUsePrivilegedPort:
		intptr = &options->use_privileged_port;
		goto parse_flag;

	case oPasswordAuthentication:
		intptr = &options->password_authentication;
		goto parse_flag;

	case oKbdInteractiveAuthentication:
		intptr = &options->kbd_interactive_authentication;
		goto parse_flag;

	case oKbdInteractiveDevices:
		charptr = &options->kbd_interactive_devices;
		goto parse_string;

	case oPubkeyAuthentication:
		intptr = &options->pubkey_authentication;
		goto parse_flag;

	case oRSAAuthentication:
		intptr = &options->rsa_authentication;
		goto parse_flag;

	case oRhostsRSAAuthentication:
		intptr = &options->rhosts_rsa_authentication;
		goto parse_flag;

	case oHostbasedAuthentication:
		intptr = &options->hostbased_authentication;
		goto parse_flag;

	case oChallengeResponseAuthentication:
		intptr = &options->challenge_response_authentication;
		goto parse_flag;

	case oGssAuthentication:
		intptr = &options->gss_authentication;
		goto parse_flag;

	case oGssDelegateCreds:
		intptr = &options->gss_deleg_creds;
		goto parse_flag;

	case oBatchMode:
		intptr = &options->batch_mode;
		goto parse_flag;

	case oCheckHostIP:
		intptr = &options->check_host_ip;
		goto parse_flag;

	case oVerifyHostKeyDNS:
		intptr = &options->verify_host_key_dns;
		multistate_ptr = multistate_yesnoask;
		goto parse_multistate;

	case oStrictHostKeyChecking:
		intptr = &options->strict_host_key_checking;
		multistate_ptr = multistate_yesnoask;
		goto parse_multistate;

	case oCompression:
		intptr = &options->compression;
		goto parse_flag;

	case oTCPKeepAlive:
		intptr = &options->tcp_keep_alive;
		goto parse_flag;

	case oNoHostAuthenticationForLocalhost:
		intptr = &options->no_host_authentication_for_localhost;
		goto parse_flag;

	case oNumberOfPasswordPrompts:
		intptr = &options->number_of_password_prompts;
		goto parse_int;

	case oCompressionLevel:
		intptr = &options->compression_level;
		goto parse_int;

	case oRekeyLimit:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename,
			    linenum);
		if (strcmp(arg, "default") == 0) {
			val64 = 0;
		} else {
			if (scan_scaled(arg, &val64) == -1)
				fatal("%.200s line %d: Bad number '%s': %s",
				    filename, linenum, arg, strerror(errno));
			/* check for too-large or too-small limits */
			if (val64 > UINT_MAX)
				fatal("%.200s line %d: RekeyLimit too large",
				    filename, linenum);
			if (val64 != 0 && val64 < 16)
				fatal("%.200s line %d: RekeyLimit too small",
				    filename, linenum);
		}
		if (*activep && options->rekey_limit == -1)
			options->rekey_limit = (u_int32_t)val64;
		if (s != NULL) { /* optional rekey interval present */
			if (strcmp(s, "none") == 0) {
				(void)strdelim(&s);	/* discard */
				break;
			}
			intptr = &options->rekey_interval;
			goto parse_time;
		}
		break;

	case oIdentityFile:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		if (*activep) {
			intptr = &options->num_identity_files;
			if (*intptr >= SSH_MAX_IDENTITY_FILES)
				fatal("%.200s line %d: Too many identity files specified (max %d).",
				    filename, linenum, SSH_MAX_IDENTITY_FILES);
			add_identity_file(options, NULL, arg, userconfig);
		}
		break;

	case oXAuthLocation:
		charptr=&options->xauth_location;
		goto parse_string;

	case oUser:
		charptr = &options->user;
parse_string:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.",
			    filename, linenum);
		if (*activep && *charptr == NULL)
			*charptr = xstrdup(arg);
		break;

	case oGlobalKnownHostsFile:
		cpptr = (char **)&options->system_hostfiles;
		uintptr = &options->num_system_hostfiles;
		max_entries = SSH_MAX_HOSTS_FILES;
parse_char_array:
		if (*activep && *uintptr == 0) {
			while ((arg = strdelim(&s)) != NULL && *arg != '\0') {
				if ((*uintptr) >= max_entries)
					fatal("%s line %d: "
					    "too many authorized keys files.",
					    filename, linenum);
				cpptr[(*uintptr)++] = xstrdup(arg);
			}
		}
		return 0;

	case oUserKnownHostsFile:
		cpptr = (char **)&options->user_hostfiles;
		uintptr = &options->num_user_hostfiles;
		max_entries = SSH_MAX_HOSTS_FILES;
		goto parse_char_array;

	case oHostName:
		charptr = &options->hostname;
		goto parse_string;

	case oHostKeyAlias:
		charptr = &options->host_key_alias;
		goto parse_string;

	case oPreferredAuthentications:
		charptr = &options->preferred_authentications;
		goto parse_string;

	case oBindAddress:
		charptr = &options->bind_address;
		goto parse_string;

	case oPKCS11Provider:
		charptr = &options->pkcs11_provider;
		goto parse_string;

	case oProxyCommand:
		charptr = &options->proxy_command;
parse_command:
		if (s == NULL)
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		len = strspn(s, WHITESPACE "=");
		if (*activep && *charptr == NULL)
			*charptr = xstrdup(s + len);
		return 0;

	case oPort:
		intptr = &options->port;
parse_int:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		if (arg[0] < '0' || arg[0] > '9')
			fatal("%.200s line %d: Bad number.", filename, linenum);

		/* Octal, decimal, or hex format? */
		value = strtol(arg, &endofnumber, 0);
		if (arg == endofnumber)
			fatal("%.200s line %d: Bad number.", filename, linenum);
		if (*activep && *intptr == -1)
			*intptr = value;
		break;

	case oConnectionAttempts:
		intptr = &options->connection_attempts;
		goto parse_int;

	case oCipher:
		intptr = &options->cipher;
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		value = cipher_number(arg);
		if (value == -1)
			fatal("%.200s line %d: Bad cipher '%s'.",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && *intptr == -1)
			*intptr = value;
		break;

	case oCiphers:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		if (!ciphers_valid(arg))
			fatal("%.200s line %d: Bad SSH2 cipher spec '%s'.",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && options->ciphers == NULL)
			options->ciphers = xstrdup(arg);
		break;

	case oMacs:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		if (!mac_valid(arg))
			fatal("%.200s line %d: Bad SSH2 Mac spec '%s'.",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && options->macs == NULL)
			options->macs = xstrdup(arg);
		break;

	case oKexAlgorithms:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.",
			    filename, linenum);
		if (!kex_names_valid(arg))
			fatal("%.200s line %d: Bad SSH2 KexAlgorithms '%s'.",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && options->kex_algorithms == NULL)
			options->kex_algorithms = xstrdup(arg);
		break;

	case oHostKeyAlgorithms:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		if (!key_names_valid2(arg))
			fatal("%.200s line %d: Bad protocol 2 host key algorithms '%s'.",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && options->hostkeyalgorithms == NULL)
			options->hostkeyalgorithms = xstrdup(arg);
		break;

	case oProtocol:
		intptr = &options->protocol;
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		value = proto_spec(arg);
		if (value == SSH_PROTO_UNKNOWN)
			fatal("%.200s line %d: Bad protocol spec '%s'.",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && *intptr == SSH_PROTO_UNKNOWN)
			*intptr = value;
		break;

	case oLogLevel:
		log_level_ptr = &options->log_level;
		arg = strdelim(&s);
		value = log_level_number(arg);
		if (value == SYSLOG_LEVEL_NOT_SET)
			fatal("%.200s line %d: unsupported log level '%s'",
			    filename, linenum, arg ? arg : "<NONE>");
		if (*activep && *log_level_ptr == SYSLOG_LEVEL_NOT_SET)
			*log_level_ptr = (LogLevel) value;
		break;

	case oLocalForward:
	case oRemoteForward:
	case oDynamicForward:
		arg = strdelim(&s);
		if (arg == NULL || *arg == '\0')
			fatal("%.200s line %d: Missing port argument.",
			    filename, linenum);

		if (opcode == oLocalForward ||
		    opcode == oRemoteForward) {
			arg2 = strdelim(&s);
			if (arg2 == NULL || *arg2 == '\0')
				fatal("%.200s line %d: Missing target argument.",
				    filename, linenum);

			/* construct a string for parse_forward */
			snprintf(fwdarg, sizeof(fwdarg), "%s:%s", arg, arg2);
		} else if (opcode == oDynamicForward) {
			strlcpy(fwdarg, arg, sizeof(fwdarg));
		}

		if (parse_forward(&fwd, fwdarg,
		    opcode == oDynamicForward ? 1 : 0,
		    opcode == oRemoteForward ? 1 : 0) == 0)
			fatal("%.200s line %d: Bad forwarding specification.",
			    filename, linenum);

		if (*activep) {
			if (opcode == oLocalForward ||
			    opcode == oDynamicForward)
				add_local_forward(options, &fwd);
			else if (opcode == oRemoteForward)
				add_remote_forward(options, &fwd);
		}
		break;

	case oClearAllForwardings:
		intptr = &options->clear_forwardings;
		goto parse_flag;

	case oHost:
		if (cmdline)
			fatal("Host directive not supported as a command-line "
			    "option");
		*activep = 0;
		arg2 = NULL;
		while ((arg = strdelim(&s)) != NULL && *arg != '\0') {
			negated = *arg == '!';
			if (negated)
				arg++;
			if (match_pattern(host, arg)) {
				if (negated) {
					debug("%.200s line %d: Skipping Host "
					    "block because of negated match "
					    "for %.100s", filename, linenum,
					    arg);
					*activep = 0;
					break;
				}
				if (!*activep)
					arg2 = arg; /* logged below */
				*activep = 1;
			}
		}
		if (*activep)
			debug("%.200s line %d: Applying options for %.100s",
			    filename, linenum, arg2);
		/* Avoid garbage check below, as strdelim is done. */
		return 0;

	case oMatch:
		if (cmdline)
			fatal("Host directive not supported as a command-line "
			    "option");
		value = match_cfg_line(options, &s, pw, host,
		    filename, linenum);
		if (value < 0)
			fatal("%.200s line %d: Bad Match condition", filename,
			    linenum);
		*activep = value;
		break;

	case oEscapeChar:
		intptr = &options->escape_char;
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		if (arg[0] == '^' && arg[2] == 0 &&
		    (u_char) arg[1] >= 64 && (u_char) arg[1] < 128)
			value = (u_char) arg[1] & 31;
		else if (strlen(arg) == 1)
			value = (u_char) arg[0];
		else if (strcmp(arg, "none") == 0)
			value = SSH_ESCAPECHAR_NONE;
		else {
			fatal("%.200s line %d: Bad escape character.",
			    filename, linenum);
			/* NOTREACHED */
			value = 0;	/* Avoid compiler warning. */
		}
		if (*activep && *intptr == -1)
			*intptr = value;
		break;

	case oAddressFamily:
		intptr = &options->address_family;
		multistate_ptr = multistate_addressfamily;
		goto parse_multistate;

	case oEnableSSHKeysign:
		intptr = &options->enable_ssh_keysign;
		goto parse_flag;

	case oIdentitiesOnly:
		intptr = &options->identities_only;
		goto parse_flag;

	case oServerAliveInterval:
		intptr = &options->server_alive_interval;
		goto parse_time;

	case oServerAliveCountMax:
		intptr = &options->server_alive_count_max;
		goto parse_int;

	case oSendEnv:
		while ((arg = strdelim(&s)) != NULL && *arg != '\0') {
			if (strchr(arg, '=') != NULL)
				fatal("%s line %d: Invalid environment name.",
				    filename, linenum);
			if (!*activep)
				continue;
			if (options->num_send_env >= MAX_SEND_ENV)
				fatal("%s line %d: too many send env.",
				    filename, linenum);
			options->send_env[options->num_send_env++] =
			    xstrdup(arg);
		}
		break;

	case oControlPath:
		charptr = &options->control_path;
		goto parse_string;

	case oControlMaster:
		intptr = &options->control_master;
		multistate_ptr = multistate_controlmaster;
		goto parse_multistate;

	case oControlPersist:
		/* no/false/yes/true, or a time spec */
		intptr = &options->control_persist;
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing ControlPersist"
			    " argument.", filename, linenum);
		value = 0;
		value2 = 0;	/* timeout */
		if (strcmp(arg, "no") == 0 || strcmp(arg, "false") == 0)
			value = 0;
		else if (strcmp(arg, "yes") == 0 || strcmp(arg, "true") == 0)
			value = 1;
		else if ((value2 = convtime(arg)) >= 0)
			value = 1;
		else
			fatal("%.200s line %d: Bad ControlPersist argument.",
			    filename, linenum);
		if (*activep && *intptr == -1) {
			*intptr = value;
			options->control_persist_timeout = value2;
		}
		break;

	case oHashKnownHosts:
		intptr = &options->hash_known_hosts;
		goto parse_flag;

	case oTunnel:
		intptr = &options->tun_open;
		multistate_ptr = multistate_tunnel;
		goto parse_multistate;

	case oTunnelDevice:
		arg = strdelim(&s);
		if (!arg || *arg == '\0')
			fatal("%.200s line %d: Missing argument.", filename, linenum);
		value = a2tun(arg, &value2);
		if (value == SSH_TUNID_ERR)
			fatal("%.200s line %d: Bad tun device.", filename, linenum);
		if (*activep) {
			options->tun_local = value;
			options->tun_remote = value2;
		}
		break;

	case oLocalCommand:
		charptr = &options->local_command;
		goto parse_command;

	case oPermitLocalCommand:
		intptr = &options->permit_local_command;
		goto parse_flag;

	case oVisualHostKey:
		intptr = &options->visual_host_key;
		goto parse_flag;

	case oIPQoS:
		arg = strdelim(&s);
		if ((value = parse_ipqos(arg)) == -1)
			fatal("%s line %d: Bad IPQoS value: %s",
			    filename, linenum, arg);
		arg = strdelim(&s);
		if (arg == NULL)
			value2 = value;
		else if ((value2 = parse_ipqos(arg)) == -1)
			fatal("%s line %d: Bad IPQoS value: %s",
			    filename, linenum, arg);
		if (*activep) {
			options->ip_qos_interactive = value;
			options->ip_qos_bulk = value2;
		}
		break;

	case oUseRoaming:
		intptr = &options->use_roaming;
		goto parse_flag;

	case oRequestTTY:
		intptr = &options->request_tty;
		multistate_ptr = multistate_requesttty;
		goto parse_multistate;

	case oHPNDisabled:
		intptr = &options->hpn_disabled;
		goto parse_flag;

	case oHPNBufferSize:
		intptr = &options->hpn_buffer_size;
		goto parse_int;

	case oTcpRcvBufPoll:
		intptr = &options->tcp_rcv_buf_poll;
		goto parse_flag;

	case oTcpRcvBuf:
		intptr = &options->tcp_rcv_buf;
		goto parse_int;

#ifdef	NONE_CIPHER_ENABLED
	case oNoneEnabled:
		intptr = &options->none_enabled;
		goto parse_flag;

	/*
	 * We check to see if the command comes from the command line or not.
	 * If it does then enable it otherwise fail.  NONE must never be a
	 * default configuration.
	 */
	case oNoneSwitch:
		if (strcmp(filename,"command-line") == 0) {
			intptr = &options->none_switch;
			goto parse_flag;
		} else {
			debug("NoneSwitch directive found in %.200s.",
			    filename);
			error("NoneSwitch is found in %.200s.\n"
			    "You may only use this configuration option "
			    "from the command line", filename);
			error("Continuing...");
			return 0;
		}
#endif

	case oVersionAddendum:
		if (s == NULL)
			fatal("%.200s line %d: Missing argument.", filename,
			    linenum);
		len = strspn(s, WHITESPACE);
		if (*activep && options->version_addendum == NULL) {
			if (strcasecmp(s + len, "none") == 0)
				options->version_addendum = xstrdup("");
			else if (strchr(s + len, '\r') != NULL)
				fatal("%.200s line %d: Invalid argument",
				    filename, linenum);
			else
				options->version_addendum = xstrdup(s + len);
		}
		return 0;

	case oIgnoreUnknown:
		charptr = &options->ignored_unknown;
		goto parse_string;

	case oProxyUseFdpass:
		intptr = &options->proxy_use_fdpass;
		goto parse_flag;

	case oCanonicalDomains:
		value = options->num_canonical_domains != 0;
		while ((arg = strdelim(&s)) != NULL && *arg != '\0') {
			valid_domain(arg, filename, linenum);
			if (!*activep || value)
				continue;
			if (options->num_canonical_domains >= MAX_CANON_DOMAINS)
				fatal("%s line %d: too many hostname suffixes.",
				    filename, linenum);
			options->canonical_domains[
			    options->num_canonical_domains++] = xstrdup(arg);
		}
		break;

	case oCanonicalizePermittedCNAMEs:
		value = options->num_permitted_cnames != 0;
		while ((arg = strdelim(&s)) != NULL && *arg != '\0') {
			/* Either '*' for everything or 'list:list' */
			if (strcmp(arg, "*") == 0)
				arg2 = arg;
			else {
				lowercase(arg);
				if ((arg2 = strchr(arg, ':')) == NULL ||
				    arg2[1] == '\0') {
					fatal("%s line %d: "
					    "Invalid permitted CNAME \"%s\"",
					    filename, linenum, arg);
				}
				*arg2 = '\0';
				arg2++;
			}
			if (!*activep || value)
				continue;
			if (options->num_permitted_cnames >= MAX_CANON_DOMAINS)
				fatal("%s line %d: too many permitted CNAMEs.",
				    filename, linenum);
			cname = options->permitted_cnames +
			    options->num_permitted_cnames++;
			cname->source_list = xstrdup(arg);
			cname->target_list = xstrdup(arg2);
		}
		break;

	case oCanonicalizeHostname:
		intptr = &options->canonicalize_hostname;
		multistate_ptr = multistate_canonicalizehostname;
		goto parse_multistate;

	case oCanonicalizeMaxDots:
		intptr = &options->canonicalize_max_dots;
		goto parse_int;

	case oCanonicalizeFallbackLocal:
		intptr = &options->canonicalize_fallback_local;
		goto parse_flag;

	case oDeprecated:
		debug("%s line %d: Deprecated option \"%s\"",
		    filename, linenum, keyword);
		return 0;

	case oUnsupported:
		error("%s line %d: Unsupported option \"%s\"",
		    filename, linenum, keyword);
		return 0;

	default:
		fatal("process_config_line: Unimplemented opcode %d", opcode);
	}

	/* Check that there is no garbage at end of line. */
	if ((arg = strdelim(&s)) != NULL && *arg != '\0') {
		fatal("%.200s line %d: garbage at end of line; \"%.200s\".",
		    filename, linenum, arg);
	}
	return 0;
}

/*
 * Reads the config file and modifies the options accordingly.  Options
 * should already be initialized before this call.  This never returns if
 * there is an error.  If the file does not exist, this returns 0.
 */

int
read_config_file(const char *filename, struct passwd *pw, const char *host,
    Options *options, int flags)
{
	FILE *f;
	char line[1024];
	int active, linenum;
	int bad_options = 0;

	if ((f = fopen(filename, "r")) == NULL)
		return 0;

	if (flags & SSHCONF_CHECKPERM) {
		struct stat sb;

		if (fstat(fileno(f), &sb) == -1)
			fatal("fstat %s: %s", filename, strerror(errno));
		if (((sb.st_uid != 0 && sb.st_uid != getuid()) ||
		    (sb.st_mode & 022) != 0))
			fatal("Bad owner or permissions on %s", filename);
	}

	debug("Reading configuration data %.200s", filename);

	/*
	 * Mark that we are now processing the options.  This flag is turned
	 * on/off by Host specifications.
	 */
	active = 1;
	linenum = 0;
	while (fgets(line, sizeof(line), f)) {
		/* Update line number counter. */
		linenum++;
		if (process_config_line(options, pw, host, line, filename,
		    linenum, &active, flags & SSHCONF_USERCONF) != 0)
			bad_options++;
	}
	fclose(f);
	if (bad_options > 0)
		fatal("%s: terminating, %d bad configuration options",
		    filename, bad_options);
	return 1;
}

/* Returns 1 if a string option is unset or set to "none" or 0 otherwise. */
int
option_clear_or_none(const char *o)
{
	return o == NULL || strcasecmp(o, "none") == 0;
}

/*
 * Initializes options to special values that indicate that they have not yet
 * been set.  Read_config_file will only set options with this value. Options
 * are processed in the following order: command line, user config file,
 * system config file.  Last, fill_default_options is called.
 */

void
initialize_options(Options * options)
{
	memset(options, 'X', sizeof(*options));
	options->forward_agent = -1;
	options->forward_x11 = -1;
	options->forward_x11_trusted = -1;
	options->forward_x11_timeout = -1;
	options->exit_on_forward_failure = -1;
	options->xauth_location = NULL;
	options->gateway_ports = -1;
	options->use_privileged_port = -1;
	options->rsa_authentication = -1;
	options->pubkey_authentication = -1;
	options->challenge_response_authentication = -1;
	options->gss_authentication = -1;
	options->gss_deleg_creds = -1;
	options->password_authentication = -1;
	options->kbd_interactive_authentication = -1;
	options->kbd_interactive_devices = NULL;
	options->rhosts_rsa_authentication = -1;
	options->hostbased_authentication = -1;
	options->batch_mode = -1;
	options->check_host_ip = -1;
	options->strict_host_key_checking = -1;
	options->compression = -1;
	options->tcp_keep_alive = -1;
	options->compression_level = -1;
	options->port = -1;
	options->address_family = -1;
	options->connection_attempts = -1;
	options->connection_timeout = -1;
	options->number_of_password_prompts = -1;
	options->cipher = -1;
	options->ciphers = NULL;
	options->macs = NULL;
	options->kex_algorithms = NULL;
	options->hostkeyalgorithms = NULL;
	options->protocol = SSH_PROTO_UNKNOWN;
	options->num_identity_files = 0;
	options->hostname = NULL;
	options->host_key_alias = NULL;
	options->proxy_command = NULL;
	options->user = NULL;
	options->escape_char = -1;
	options->num_system_hostfiles = 0;
	options->num_user_hostfiles = 0;
	options->local_forwards = NULL;
	options->num_local_forwards = 0;
	options->remote_forwards = NULL;
	options->num_remote_forwards = 0;
	options->clear_forwardings = -1;
	options->log_level = SYSLOG_LEVEL_NOT_SET;
	options->preferred_authentications = NULL;
	options->bind_address = NULL;
	options->pkcs11_provider = NULL;
	options->enable_ssh_keysign = - 1;
	options->no_host_authentication_for_localhost = - 1;
	options->identities_only = - 1;
	options->rekey_limit = - 1;
	options->rekey_interval = -1;
	options->verify_host_key_dns = -1;
	options->server_alive_interval = -1;
	options->server_alive_count_max = -1;
	options->num_send_env = 0;
	options->control_path = NULL;
	options->control_master = -1;
	options->control_persist = -1;
	options->control_persist_timeout = 0;
	options->hash_known_hosts = -1;
	options->tun_open = -1;
	options->tun_local = -1;
	options->tun_remote = -1;
	options->local_command = NULL;
	options->permit_local_command = -1;
	options->use_roaming = 0;
	options->visual_host_key = -1;
	options->ip_qos_interactive = -1;
	options->ip_qos_bulk = -1;
	options->request_tty = -1;
	options->proxy_use_fdpass = -1;
	options->ignored_unknown = NULL;
	options->num_canonical_domains = 0;
	options->num_permitted_cnames = 0;
	options->canonicalize_max_dots = -1;
	options->canonicalize_fallback_local = -1;
	options->canonicalize_hostname = -1;
	options->version_addendum = NULL;
	options->hpn_disabled = -1;
	options->hpn_buffer_size = -1;
	options->tcp_rcv_buf_poll = -1;
	options->tcp_rcv_buf = -1;
#ifdef NONE_CIPHER_ENABLED
	options->none_enabled = -1;
	options->none_switch = -1;
#endif
}

/*
 * A petite version of fill_default_options() that just fills the options
 * needed for hostname canonicalization to proceed.
 */
void
fill_default_options_for_canonicalization(Options *options)
{
	if (options->canonicalize_max_dots == -1)
		options->canonicalize_max_dots = 1;
	if (options->canonicalize_fallback_local == -1)
		options->canonicalize_fallback_local = 1;
	if (options->canonicalize_hostname == -1)
		options->canonicalize_hostname = SSH_CANONICALISE_NO;
}

/*
 * Called after processing other sources of option data, this fills those
 * options for which no value has been specified with their default values.
 */
void
fill_default_options(Options * options)
{
	if (options->forward_agent == -1)
		options->forward_agent = 0;
	if (options->forward_x11 == -1)
		options->forward_x11 = 0;
	if (options->forward_x11_trusted == -1)
		options->forward_x11_trusted = 0;
	if (options->forward_x11_timeout == -1)
		options->forward_x11_timeout = 1200;
	if (options->exit_on_forward_failure == -1)
		options->exit_on_forward_failure = 0;
	if (options->xauth_location == NULL)
		options->xauth_location = _PATH_XAUTH;
	if (options->gateway_ports == -1)
		options->gateway_ports = 0;
	if (options->use_privileged_port == -1)
		options->use_privileged_port = 0;
	if (options->rsa_authentication == -1)
		options->rsa_authentication = 1;
	if (options->pubkey_authentication == -1)
		options->pubkey_authentication = 1;
	if (options->challenge_response_authentication == -1)
		options->challenge_response_authentication = 1;
	if (options->gss_authentication == -1)
		options->gss_authentication = 0;
	if (options->gss_deleg_creds == -1)
		options->gss_deleg_creds = 0;
	if (options->password_authentication == -1)
		options->password_authentication = 1;
	if (options->kbd_interactive_authentication == -1)
		options->kbd_interactive_authentication = 1;
	if (options->rhosts_rsa_authentication == -1)
		options->rhosts_rsa_authentication = 0;
	if (options->hostbased_authentication == -1)
		options->hostbased_authentication = 0;
	if (options->batch_mode == -1)
		options->batch_mode = 0;
	if (options->check_host_ip == -1)
		options->check_host_ip = 0;
	if (options->strict_host_key_checking == -1)
		options->strict_host_key_checking = 2;	/* 2 is default */
	if (options->compression == -1)
		options->compression = 0;
	if (options->tcp_keep_alive == -1)
		options->tcp_keep_alive = 1;
	if (options->compression_level == -1)
		options->compression_level = 6;
	if (options->port == -1)
		options->port = 0;	/* Filled in ssh_connect. */
	if (options->address_family == -1)
		options->address_family = AF_UNSPEC;
	if (options->connection_attempts == -1)
		options->connection_attempts = 1;
	if (options->number_of_password_prompts == -1)
		options->number_of_password_prompts = 3;
	/* Selected in ssh_login(). */
	if (options->cipher == -1)
		options->cipher = SSH_CIPHER_NOT_SET;
	/* options->ciphers, default set in myproposals.h */
	/* options->macs, default set in myproposals.h */
	/* options->kex_algorithms, default set in myproposals.h */
	/* options->hostkeyalgorithms, default set in myproposals.h */
	if (options->protocol == SSH_PROTO_UNKNOWN)
		options->protocol = SSH_PROTO_2;
	if (options->num_identity_files == 0) {
		if (options->protocol & SSH_PROTO_1) {
			add_identity_file(options, "~/",
			    _PATH_SSH_CLIENT_IDENTITY, 0);
		}
		if (options->protocol & SSH_PROTO_2) {
			add_identity_file(options, "~/",
			    _PATH_SSH_CLIENT_ID_RSA, 0);
			add_identity_file(options, "~/",
			    _PATH_SSH_CLIENT_ID_DSA, 0);
#ifdef OPENSSL_HAS_ECC
			add_identity_file(options, "~/",
			    _PATH_SSH_CLIENT_ID_ECDSA, 0);
#endif
			add_identity_file(options, "~/",
			    _PATH_SSH_CLIENT_ID_ED25519, 0);
		}
	}
	if (options->escape_char == -1)
		options->escape_char = '~';
	if (options->num_system_hostfiles == 0) {
		options->system_hostfiles[options->num_system_hostfiles++] =
		    xstrdup(_PATH_SSH_SYSTEM_HOSTFILE);
		options->system_hostfiles[options->num_system_hostfiles++] =
		    xstrdup(_PATH_SSH_SYSTEM_HOSTFILE2);
	}
	if (options->num_user_hostfiles == 0) {
		options->user_hostfiles[options->num_user_hostfiles++] =
		    xstrdup(_PATH_SSH_USER_HOSTFILE);
		options->user_hostfiles[options->num_user_hostfiles++] =
		    xstrdup(_PATH_SSH_USER_HOSTFILE2);
	}
	if (options->log_level == SYSLOG_LEVEL_NOT_SET)
		options->log_level = SYSLOG_LEVEL_INFO;
	if (options->clear_forwardings == 1)
		clear_forwardings(options);
	if (options->no_host_authentication_for_localhost == - 1)
		options->no_host_authentication_for_localhost = 0;
	if (options->identities_only == -1)
		options->identities_only = 0;
	if (options->enable_ssh_keysign == -1)
		options->enable_ssh_keysign = 0;
	if (options->rekey_limit == -1)
		options->rekey_limit = 0;
	if (options->rekey_interval == -1)
		options->rekey_interval = 0;
#if HAVE_LDNS
	if (options->verify_host_key_dns == -1)
		/* automatically trust a verified SSHFP record */
		options->verify_host_key_dns = 1;
#else
	if (options->verify_host_key_dns == -1)
		options->verify_host_key_dns = 0;
#endif
	if (options->server_alive_interval == -1)
		options->server_alive_interval = 0;
	if (options->server_alive_count_max == -1)
		options->server_alive_count_max = 3;
	if (options->control_master == -1)
		options->control_master = 0;
	if (options->control_persist == -1) {
		options->control_persist = 0;
		options->control_persist_timeout = 0;
	}
	if (options->hash_known_hosts == -1)
		options->hash_known_hosts = 0;
	if (options->tun_open == -1)
		options->tun_open = SSH_TUNMODE_NO;
	if (options->tun_local == -1)
		options->tun_local = SSH_TUNID_ANY;
	if (options->tun_remote == -1)
		options->tun_remote = SSH_TUNID_ANY;
	if (options->permit_local_command == -1)
		options->permit_local_command = 0;
	options->use_roaming = 0;
	if (options->visual_host_key == -1)
		options->visual_host_key = 0;
	if (options->ip_qos_interactive == -1)
		options->ip_qos_interactive = IPTOS_LOWDELAY;
	if (options->ip_qos_bulk == -1)
		options->ip_qos_bulk = IPTOS_THROUGHPUT;
	if (options->request_tty == -1)
		options->request_tty = REQUEST_TTY_AUTO;
	if (options->proxy_use_fdpass == -1)
		options->proxy_use_fdpass = 0;
	if (options->canonicalize_max_dots == -1)
		options->canonicalize_max_dots = 1;
	if (options->canonicalize_fallback_local == -1)
		options->canonicalize_fallback_local = 1;
	if (options->canonicalize_hostname == -1)
		options->canonicalize_hostname = SSH_CANONICALISE_NO;
#define CLEAR_ON_NONE(v) \
	do { \
		if (option_clear_or_none(v)) { \
			free(v); \
			v = NULL; \
		} \
	} while(0)
	CLEAR_ON_NONE(options->local_command);
	CLEAR_ON_NONE(options->proxy_command);
	CLEAR_ON_NONE(options->control_path);
	/* options->user will be set in the main program if appropriate */
	/* options->hostname will be set in the main program if appropriate */
	/* options->host_key_alias should not be set by default */
	/* options->preferred_authentications will be set in ssh */
	if (options->version_addendum == NULL)
		options->version_addendum = xstrdup(SSH_VERSION_FREEBSD);
	if (options->hpn_disabled == -1)
		options->hpn_disabled = 0;
	if (options->hpn_buffer_size > -1)
	{
		u_int maxlen;

		/* If a user tries to set the size to 0 set it to 1KB. */
		if (options->hpn_buffer_size == 0)
			options->hpn_buffer_size = 1024;
		/* Limit the buffer to BUFFER_MAX_LEN. */
		maxlen = buffer_get_max_len();
		if (options->hpn_buffer_size > (maxlen / 1024)) {
			debug("User requested buffer larger than %ub: %ub. "
			    "Request reverted to %ub", maxlen,
			    options->hpn_buffer_size * 1024, maxlen);
			options->hpn_buffer_size = maxlen;
		}
		debug("hpn_buffer_size set to %d", options->hpn_buffer_size);
	}
	if (options->tcp_rcv_buf == 0)
		options->tcp_rcv_buf = 1;
	if (options->tcp_rcv_buf > -1)
		options->tcp_rcv_buf *= 1024;
	if (options->tcp_rcv_buf_poll == -1)
		options->tcp_rcv_buf_poll = 1;
#ifdef	NONE_CIPHER_ENABLED
	/* options->none_enabled must not be set by default */
	if (options->none_switch == -1)
		options->none_switch = 0;
#endif
}

/*
 * parse_forward
 * parses a string containing a port forwarding specification of the form:
 *   dynamicfwd == 0
 *	[listenhost:]listenport:connecthost:connectport
 *   dynamicfwd == 1
 *	[listenhost:]listenport
 * returns number of arguments parsed or zero on error
 */
int
parse_forward(Forward *fwd, const char *fwdspec, int dynamicfwd, int remotefwd)
{
	int i;
	char *p, *cp, *fwdarg[4];

	memset(fwd, '\0', sizeof(*fwd));

	cp = p = xstrdup(fwdspec);

	/* skip leading spaces */
	while (isspace((u_char)*cp))
		cp++;

	for (i = 0; i < 4; ++i)
		if ((fwdarg[i] = hpdelim(&cp)) == NULL)
			break;

	/* Check for trailing garbage */
	if (cp != NULL)
		i = 0;	/* failure */

	switch (i) {
	case 1:
		fwd->listen_host = NULL;
		fwd->listen_port = a2port(fwdarg[0]);
		fwd->connect_host = xstrdup("socks");
		break;

	case 2:
		fwd->listen_host = xstrdup(cleanhostname(fwdarg[0]));
		fwd->listen_port = a2port(fwdarg[1]);
		fwd->connect_host = xstrdup("socks");
		break;

	case 3:
		fwd->listen_host = NULL;
		fwd->listen_port = a2port(fwdarg[0]);
		fwd->connect_host = xstrdup(cleanhostname(fwdarg[1]));
		fwd->connect_port = a2port(fwdarg[2]);
		break;

	case 4:
		fwd->listen_host = xstrdup(cleanhostname(fwdarg[0]));
		fwd->listen_port = a2port(fwdarg[1]);
		fwd->connect_host = xstrdup(cleanhostname(fwdarg[2]));
		fwd->connect_port = a2port(fwdarg[3]);
		break;
	default:
		i = 0; /* failure */
	}

	free(p);

	if (dynamicfwd) {
		if (!(i == 1 || i == 2))
			goto fail_free;
	} else {
		if (!(i == 3 || i == 4))
			goto fail_free;
		if (fwd->connect_port <= 0)
			goto fail_free;
	}

	if (fwd->listen_port < 0 || (!remotefwd && fwd->listen_port == 0))
		goto fail_free;

	if (fwd->connect_host != NULL &&
	    strlen(fwd->connect_host) >= NI_MAXHOST)
		goto fail_free;
	if (fwd->listen_host != NULL &&
	    strlen(fwd->listen_host) >= NI_MAXHOST)
		goto fail_free;

	return (i);

 fail_free:
	free(fwd->connect_host);
	fwd->connect_host = NULL;
	free(fwd->listen_host);
	fwd->listen_host = NULL;
	return (0);
}


text:
API and widget for finding local district offices by zipcode.

Embed code:

	<iframe src="http://services.sunlightlabs.com/districtoffices/embed" width="400" height="550" scrolling="no" frameborder="0" seamless></iframe>

Data was compiled and verified by Sunlight Foundation staff. Last updated August 24, 2011.


text:
<!DOCTYPE html>

		<meta charset="utf-8" />
		<base href="../../../" />

		<link type="text/css" rel="stylesheet" href="page.css" />

[name]

		Represents a lookup table for colormaps. It is used to determine the color values from a range of data values.

Code Example

		const lut = new Lut( 'rainbow', 512 );
		const color = lut.getColor( 0.5 );

Constructor

[name]( [param:String colormap], [param:Number count] )

		colormap - Sets a colormap from predefined colormaps. Available colormaps are: `rainbow`, `cooltowarm`, `blackbody`, `grayscale`. Default is `rainbow`.

		count - Sets the number of colors used to represent the data array. Default is `32`.

Properties

[property:Array lut]

		The lookup table for the selected color map represented as an array of [page:Color]s.

[property:Array map]

		The currently selected color map. Default is the `rainbow` color map.

[property:Number minV]

		The minimum value to be represented with the lookup table. Default is *0*.

[property:Number maxV]

		The maximum value to be represented with the lookup table. Default is *1*.

[property:Number n]

		The number of colors of the current selected color map. Default is `32`.

Methods

[method:this copy]( [param:Lut lut] ) [param:Lut this]

		color — Lut to copy.

		Copies the given lut.

[method:this addColorMap]( [param:String name], [param:Array arrayOfColors] )

		name — The name of the color map.

		arrayOfColors — An array of color values. Each value is an array holding a threshold and the actual color value as a hexadecimal number.

		Adds a color map to this [name] instance.

[method:HTMLCanvasElement createCanvas]()

		Creates a canvas in order to visualize the lookup table as a texture.

[method:Color getColor]( [param:Number alpha] )

		value -- the data value to be displayed as a color.

		Returns an instance of [page:Color] for the given data value.

[method:this setColorMap]( [param:String colormap], [param:Number count] )

		colormap — The name of the color map.

		count — The number of colors. Default is `32`.

		Configure the lookup table for the given color map and number of colors.

[method:this setMin]( [param:Number minV] )

		minV — The minimum value to be represented with the lookup table

		Sets this Lut with the minimum value to be represented.

[method:this setMax]( [param:Number maxV] )

		maxV — The maximum value to be represented with the lookup table.

		Sets this Lut with the maximum value to be represented.

[method:HTMLCanvasElement updateCanvas]( [param:HTMLCanvasElement canvas] )

		Updates the canvas with the [name]'s data.

Source

			[link:https://github.com/mrdoob/three.js/blob/master/examples/jsm/math/Lut.js examples/jsm/math/Lut.js]


text:
<?php

namespace Facebook\Libphutil;

/**
 * Authentication adapter for JIRA OAuth1.
 */
class PhutilAuthAdapterOAuthJIRA extends \Facebook\Libphutil\PhutilAuthAdapterOAuth1 {

  // TODO: JIRA tokens expire (after 5 years) and we could surface and store
  // that.

  private $jiraBaseURI;
  private $adapterDomain;
  private $currentSession;
  private $userInfo;

  public function setJIRABaseURI($jira_base_uri) {
    $this->jiraBaseURI = $jira_base_uri;
    return $this;
  }

  public function getJIRABaseURI() {
    return $this->jiraBaseURI;
  }

  public function getAccountID() {
    // Make sure the handshake is finished; this method is used for its
    // side effect by Auth providers.
    $this->getHandshakeData();

    return \Facebook\Libphutil\Functions\utils::idx($this->getUserInfo(), 'key');
  }

  public function getAccountName() {
    return \Facebook\Libphutil\Functions\utils::idx($this->getUserInfo(), 'name');
  }

  public function getAccountImageURI() {
    $avatars = \Facebook\Libphutil\Functions\utils::idx($this->getUserInfo(), 'avatarUrls');
    if ($avatars) {
      return \Facebook\Libphutil\Functions\utils::idx($avatars, '48x48');
    }
    return null;
  }

  public function getAccountRealName() {
    return \Facebook\Libphutil\Functions\utils::idx($this->getUserInfo(), 'displayName');
  }

  public function getAccountEmail() {
    return \Facebook\Libphutil\Functions\utils::idx($this->getUserInfo(), 'emailAddress');
  }

  public function getAdapterType() {
    return 'jira';
  }

  public function getAdapterDomain() {
    return $this->adapterDomain;
  }

  public function setAdapterDomain($domain) {
    $this->adapterDomain = $domain;
    return $this;
  }

  protected function getSignatureMethod() {
    return 'RSA-SHA1';
  }

  protected function getRequestTokenURI() {
    return $this->getJIRAURI('plugins/servlet/oauth/request-token');
  }

  protected function getAuthorizeTokenURI() {
    return $this->getJIRAURI('plugins/servlet/oauth/authorize');
  }

  protected function getValidateTokenURI() {
    return $this->getJIRAURI('plugins/servlet/oauth/access-token');
  }

  private function getJIRAURI($path) {
    return rtrim($this->jiraBaseURI, '/').'/'.ltrim($path, '/');
  }

  private function getUserInfo() {
    if ($this->userInfo === null) {
      $this->currentSession = $this->newJIRAFuture('rest/auth/1/session', 'GET')
        ->resolveJSON();

      // The session call gives us the username, but not the user key or other
      // information. Make a second call to get additional information.

      $params = array(
        'username' => $this->currentSession['name'],
      );

      $this->userInfo = $this->newJIRAFuture('rest/api/2/user', 'GET', $params)
        ->resolveJSON();
    }

    return $this->userInfo;
  }

  public static function newJIRAKeypair() {
    $config = array(
      'digest_alg' => 'sha512',
      'private_key_bits' => 4096,
      'private_key_type' => OPENSSL_KEYTYPE_RSA,
    );

    $res = openssl_pkey_new($config);
    if (!$res) {
      throw new \Exception('openssl_pkey_new() failed!');
    }

    $private_key = null;
    $ok = openssl_pkey_export($res, $private_key);
    if (!$ok) {
      throw new \Exception('openssl_pkey_export() failed!');
    }

    $public_key = openssl_pkey_get_details($res);
    if (!$ok || empty($public_key['key'])) {
      throw new \Exception('openssl_pkey_get_details() failed!');
    }
    $public_key = $public_key['key'];

    return array($public_key, $private_key);
  }

  /**
   * JIRA indicates that the user has clicked the "Deny" button by passing a
   * well known `oauth_verifier` value ("denied"), which we check for here.
   */
  protected function willFinishOAuthHandshake() {
    $jira_magic_word = "denied";
    if ($this->getVerifier() == $jira_magic_word) {
      throw new \Facebook\Libphutil\PhutilAuthUserAbortedException();
    }
  }

  public function newJIRAFuture($path, $method, $params = array()) {
    $uri = new \Facebook\Libphutil\PhutilURI($this->getJIRAURI($path));
    if ($method == 'GET') {
      $uri->setQueryParams($params);
      $params = array();
    } else {
      // For other types of requests, JIRA expects the request body to be
      // JSON encoded.
      $params = json_encode($params);
    }

    // JIRA returns a 415 error if we don't provide a Content-Type header.

    return $this->newOAuth1Future($uri, $params)
      ->setMethod($method)
      ->addHeader('Content-Type', 'application/json');
  }

}


text:
<?php
// Page title
$_['title_category_list']    = 'Categories List';
$_['title_category_insert']  = 'Insert Category';
$_['title_category_update']  = 'Update Category';

// Section
$_['section_metadata']          = 'Metadata';
$_['section_articles']          = 'Articles';

// Entry
$_['entry_name']                = 'Name';
$_['entry_url_alias']           = 'URL Alias';
$_['entry_description']         = 'Description';
$_['entry_meta_title']          = 'Meta Title';
$_['entry_meta_desc']           = 'Meta Description';
$_['entry_meta_keyword']        = 'Keywords';
$_['entry_robot']               = 'Robots';
$_['entry_article_order']       = 'Article Order';
$_['entry_article_image']       = 'Article Image Size';
$_['entry_char_limit']          = 'Teaser Limit';
$_['entry_cat_image']           = 'Category Image';
$_['entry_order']               = 'Sort Order';
$_['entry_parent_category']     = 'Parent Category';
$_['entry_stores']              = 'Stores';
$_['entry_suffix']              = 'Class Suffix';
$_['entry_stores']              = 'Stores';
$_['entry_layout_override']     = 'Layout Override';
$_['entry_template_override']   = 'Template Override';

$_['entry_status']              = 'Status';
$_['entry_created']             = 'Created';
$_['entry_last_update']         = 'Last Update';

// Entry Help
$_['entry_url_alias_help']          = 'Alias auto suggest turned off when the input not blank, click icon next to input to regenerate.';
$_['entry_meta_title_help']         = 'characters. Most search engine use a maximum of 60 chars for the title.';
$_['entry_meta_desc_help']          = 'characters. Most search engine use a maximum of 160 chars for the description.';
$_['entry_meta_keyword_help']       = 'Comma separated list of your site keywords.';
$_['entry_robot_help']              = 'Overwrite or inherit from global setting.';
$_['entry_article_order_help']      = 'Article Order of this category.';
$_['entry_article_image_help']      = 'Overwrite default featured image size of article inside this category. Put "0" zero to use global setting.';
$_['entry_char_limit_help']         = 'Overwrite default words limit for article. Put "0" zero to use global setting.';
$_['entry_stores_help']             = 'Category will show at the selected store.';

// Tooltip
$_['tooltip_url_alias']             = 'Regenerate URL Alias';

// Text
$_['text_input_require']            = 'Please check required input!';
$_['text_input_require_tab']        = 'Please check required input at tab <b>Content > %s</b>';
$_['text_alias_must_unique']        = 'URL Alias is not unique!';

// Text related to javascript
$_['js_saving']                 = 'Saving category..';

// Error
$_['error_permission']          = 'You not have permission to modify category!';
$_['error_permission_insert']   = 'You not have permission to insert categories!';
$_['error_permission_edit']     = 'You not have permission to edit categories!';
$_['error_permission_copy']     = 'You not have permission to copy categories!';
$_['error_permission_delete']   = 'You not have permission to delete categories!';
$_['error_copy']                = 'Category not available, copy failed!';


text:
package com.stulsoft.ysps.poption

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

/**
  * @author Yuriy Stul.
  */
class OptionListConverterTest extends AnyFlatSpec with Matchers {
  behavior of "OptionListConverter"

  "extract" should "handle List" in {
    val r = OptionListConverter.extract(List(Some("test1"), None, Some("test2")))
    r.size shouldBe 2
    r.head shouldBe "test1"
    r.tail.head shouldBe "test2"
  }

  it should "handle Seq" in {
    val r = OptionListConverter.extract(Seq(Some("test1"), None, Some("test2")))
    r.size shouldBe 2
    r.head shouldBe "test1"
    r.tail.head shouldBe "test2"
  }

  it should "handle Vector" in {
    val r = OptionListConverter.extract(Vector(Some("test1"), None, Some("test2")))
    r.size shouldBe 2
    r.head shouldBe "test1"
    r.tail.head shouldBe "test2"
  }

  it should "handle Set" in {
    val r = OptionListConverter.extract(Set(Some("test1"), None, Some("test2")))
    r.size shouldBe 2
    r.head shouldBe "test1"
    r.tail.head shouldBe "test2"
  }

}


text:
import React from "react";
import ReactDom from "react-dom";
import {Route, Router, browserHistory} from "react-router";

import './styles/styles.css';
import './styles/normalize.css';
import "./vendors/font-awesome/css/font-awesome.css";

import FoodResult from "./components/FoodResult/foodResult";
import Savedfood from "./components/Savedfood/Savedfood";

ReactDom.render(
  <Router history={browserHistory}>
    <Route path="/" component={FoodResult} />
    <Route path="/users/dashboard" component={Savedfood} />
  </Router>
  ,document.getElementById("app")
);


text:
import cloudwatch_snap
import s3_snap
import kinesis_snap

__all__ = ['cloudwatch_snap', 's3_snap', 'kinesis_snap']
snaps = [cloudwatch_snap, s3_snap, kinesis_snap]


text:
'use strict';

angular.module('game').controller('gameController', ['$scope', '$state', 'socketIoSrv', 'userSrv', 'gameSrv',
	function($scope, $state, socketIoSrv, userSrv, gameSrv) {

    if (!gameSrv.activeTableId) {
      $state.go('game.lobby');
    }

    $scope.user = userSrv.user;
    $scope.table = ( gameSrv.room.tables && gameSrv.room.tables[gameSrv.activeTableId] ) ? gameSrv.room.tables[gameSrv.activeTableId] : undefined;
    $scope.game = {};
    $scope.status = 'waitinguser';
    $scope.heronick = "hero";
    $scope.opponick = "opponent";
    $scope.herocards = {};
    $scope.oppocards = {};
    $scope.cardsLeft = 0;
    $scope.playerInActionId = '';
    $scope.roundScores = [];
    $scope.totalScores = {hero:0, oppo:0};

    $scope.setPlayersCards = function() {
      $scope.herocards = $scope.table.holeCards[userSrv.user.id];
      $scope.oppocards = $scope.table.holeCards[$scope.game.opponent.id];
    }

    $scope.sendReadyToPLay = function (gameId) {
      socketIoSrv.socket.emit('playerReadyToPlayRequest', userSrv.user.id, gameId);
    };

    $scope.$on('user.join', function (event) {
      $scope.table = gameSrv.room.tables[gameSrv.activeTableId];
    });

    $scope.$on('game.started', function (event, gameId) {
      console.log('GAME STARTED');
      $scope.game = gameSrv.games[gameId];
      $scope.status = 'readytostart';
    });

    $scope.$on('game.running', function (event, gameId) {
      console.log('GAME RUNNING');
      $scope.status = 'running';

      // sets player local nicknames (useful for scores)
      _.each($scope.table.players, function(player,id,list){
        if (player.id === $scope.user.id) {
          $scope.heronick = player.nickName;
        } else {
          $scope.opponick = player.nickName;
        }
      });
    });

    $scope.$on('game.resume', function (event, gameId) {
      console.log('GAME RESUME');

      $scope.status = 'running';
      $scope.table = gameSrv.room.tables[gameSrv.activeTableId];
      $scope.game = gameSrv.games[gameId];

      _.each($scope.game.roundScores, function(score, index, list){
        $scope.roundScores.push({
          hero: score[userSrv.user.id],
          oppo: score[$scope.game.opponent.id]
        });

        $scope.totalScores = {
          hero: $scope.totalScores.hero + score[userSrv.user.id],
          oppo: $scope.totalScores.oppo + score[$scope.game.opponent.id]
        }
      });

      $scope.cardsLeft = $scope.game.cardsLeft;
      $scope.setPlayersCards();
    });

    $scope.$on('round.new', function (event, data) {
      $scope.cardsLeft = data.cardsLeft;
      $scope.setPlayersCards();
    });

    $scope.$on('player.waitforaction', function (event, data) {
      $scope.game.canPlay = ( data.playerId === userSrv.user.id );
      $scope.playerInActionId = data.playerId;
    });

    $scope.$on('player.cardplayed', function (event, data) {
      delete $scope.herocards[data.cardId];
    });

    $scope.$on('opponent.cardplayed', function (event, data) {
      //$scope.oppocards[data.card.id] = data.card;
      delete $scope.oppocards[data.card.id];
    });

    $scope.$on('turn.ended', function (event, data) {
      _.delay(function(){
        $('.move').empty();
      }, 1200);
    });

    $scope.$on('turn.drawcards', function (event, data) {
      $scope.cardsLeft = data.cardsLeft;

      $scope.setPlayersCards();
    });

    $scope.$on('round.ended', function (event, data) {
      var heroRoundScore = data.roundScore[userSrv.user.id]
        , oppoRoundScore = data.roundScore[$scope.game.opponent.id]
        , heroTotalScore = data.roundScore[userSrv.user.id]
        , oppoTotalScore = data.roundScore[$scope.game.opponent.id];

      $scope.roundScores.push({hero: heroRoundScore, oppo: oppoRoundScore});
      $scope.totalScores = {hero: $scope.totalScores.hero+heroTotalScore, oppo: $scope.totalScores.oppo+oppoTotalScore};

      //alert( "ROUND ENDED!\nYour score: " + heroRoundScore + " - Your opponent score: " + oppoRoundScore + "\nClick OK to continue the game.");
    });

    $scope.$on('game.ended', function (event, data) {
      var heroScore = data.scores[userSrv.user.id],
        villainScore = data.scores[$scope.game.opponent.id];

      if (heroScore > villainScore){
        alert( "GAME ENDED!\nGOOD JOB! You win: " + heroScore + " to " + villainScore + "\nClick OK to continue the game.");
      } else {
        alert( "GAME ENDED!\nYou loose: " + villainScore + " to " + heroScore + "\nClick OK to continue the game.");
      }

      //alert( "GAME ENDED!\nYour score: " + heroScore + " - Your opponent score: " + villainScore + "\nClick OK to continue the game.");
    });

    $scope.$on('game.suspended', function (event, data) {
      switch (data.reason){
        case 'PLAYER_DISCONNECTION':
          //alert( "GAME SUSPENDED FOR PLAYER DISCONNECTION" );

          //TODO: SHOW DISCONNECTION ON PLAYER PLACEHOLDER
          break;
      }
    });
	}
]);


text:
@page can.Control.view
@hide
@parent can.Control
@plugin can/control/view
@test can/control/view/qunit.html
@download http://donejs.com/can/dist/can.control.view.js

__DEPRECATED__

Renders a View template with the controller instance. If the first argument
is not supplied, it looks for a view in `/views/controlName/action_name.ejs`.
If data is not provided, it uses the controller instance as data.

	var Tasks = can.Control.extend('Tasks',{
		click: function( el ) {
			// renders with views/tasks/click.ejs with the control as data
			this.element.html( this.view() )

			// renders with views/tasks/click.ejs with some data
			this.element.html(
				this.view({ name : 'The task' }) );

			// renders with views/tasks/under.ejs
			this.element.html(
				this.view("under", [1,2]) );

			// renders with views/tasks/under.micro
			this.element.html(
				this.view("under.micro", [1,2]) );

			// renders with views/shared/top.ejs
			this.element.html(
				this.view("shared/top", {phrase: "hi"}) );
		}
	})

The control name will be determined by its [can.Construct.fullName fullName] so
make sure that it is set when using the plugin. If the view name doesn't include an extension the
default view extension in [can.view.ext] will be added.


text:
require './lib/eac'

describe EAC do
  context "reads file" do
    it "using EAC shorcut" do
      eac = EAC(File.read("./data/sia_walcott.xml"))
      eac.should be_a(EAC::Person)
    end

    it "using EAC::Doc.new" do
      eac = EAC::Doc.new(File.read("./data/sia_walcott.xml"))
      eac.should be_a(EAC::Doc)
    end

  end

  context "with invalid data" do
    it "needs entityType" do
      expect {
        EAC('<xml><eac-cpf xmlns="urn:isbn:1-931666-33-4"></eac></xml>')
      }.to raise_error(ArgumentError, "entityType not found")
    end
  end

  context "Person create" do
    let(:person) do
      person = nil
      File.open("./data/sia_walcott.xml") do |f|
        person = EAC(f)
      end
      person
    end

    let (:cadell) { EAC(File.read("./data/yale_cadell.xml"))}

    describe "attributes" do
      it "should have 'record_id'" do
        expect(person.record_id).to eq("RU007004")
      end

      it "should have occupations" do
        expect(person.occupations).to eq(["Paleontologist", "Geologist", "Acting Secretary in Charge of the United States National Museum", "Secretary, Smithsonian Institution"])
      end
      it "should have biography data" do
      end
    end

    context "biography" do
       context "abstract" do
         it "should be nil if no abstract present" do
           expect(person.biography.abstract).to eq('')
         end
         it "should have text if abstract present" do
           expect(cadell.biography.abstract).to include("Thomas Cadell was born in Bristol")
         end
       end
      context "notes" do
        it "should have an array of strings with content from file" do
          expect(person.biography.notes.length).to eq(7)
          expect(person.biography.notes[1]).to include("Walcott was appointed Secretary of the Smithsonian")
        end
      end
    end

    describe "with name" do
      it "finds all names" do
        person.names.length.should == 5
      end

      describe "parts" do
        it "handles a name entry with only one part" do
          single_part_name = person.names.first
          parts = single_part_name.parts
          expect(parts.length).to eq(1)
          expect(parts[0].local_type).to be_nil
          expect(parts[0].text).to eq("Walcott, Charles D. (Charles Doolittle), 1850-1927")
        end

        it "handles a name entry with multiple parts" do
          multipart_name = person.names[1]
          expect(multipart_name.parts.length).to eq(3)

          expect(multipart_name.parts[0].local_type).to eq("surname")
          expect(multipart_name.parts[0].text).to eq("Walcott")
        end
      end

      describe "reports full string" do
        it "of simple name" do
          person.names.first.to_s.should == "Walcott, Charles D. (Charles Doolittle), 1850-1927"
        end

        it "of name with multiple parts" do
          person.names[1].to_s.should == "Walcott, Charles D., 1850-1927"
        end
      end

    end
  end
end


text:
#include <errno.h>
#include <unistd.h>

/* Note: This implementation of pwrite64 is not multithread-safe.  */

ssize_t
__libc_pwrite64 (int fd, const void *buf, size_t nbyte, off64_t offset)
{
  /* Since we must not change the file pointer preserve the value so that
     we can restore it later.  */
  int save_errno;
  ssize_t result;
  off64_t old_offset = __libc_lseek64 (fd, 0, SEEK_CUR);
  if (old_offset == (off64_t) -1)
    return -1;

  /* Set to wanted position.  */
  if (__libc_lseek64 (fd, offset, SEEK_SET) == (off64_t) -1)
    return -1;

  /* Write out the data.  */
  result = __libc_write (fd, buf, nbyte);

  /* Now we have to restore the position.  If this fails we have to
     return this as an error.  But if the writing also failed we
     return this error.  */
  save_errno = errno;
  if (__libc_lseek64 (fd, old_offset, SEEK_SET) == (off64_t) -1)
    {
      if (result == -1)
	__set_errno (save_errno);
      return -1;
    }
  __set_errno (save_errno);

  return result;
}
#ifndef __libc_pwrite64
libc_hidden_def (__libc_pwrite64)
weak_alias (__libc_pwrite64, __pwrite64)
libc_hidden_weak (__pwrite64)
weak_alias (__libc_pwrite64, pwrite64)
#endif


text:
package net.sourceforge.jcctray.model;

import java.io.IOException;

import net.sourceforge.jcctray.exceptions.HTTPErrorException;
import net.sourceforge.jcctray.exceptions.InvocationException;
import net.sourceforge.jcctray.utils.StringUtils;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.SimpleHttpConnectionManager;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.params.HttpConnectionManagerParams;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.log4j.Logger;

/**
 * An abstract implementation of ICruise that can be connected to via HTTP.
 *
 * @author Ketan Padegaonkar
 */
public abstract class HTTPCruise implements ICruise {

	private static HttpClient getClient(Host host) {
		SimpleHttpConnectionManager connectionManager =  new SimpleHttpConnectionManager();
		HttpConnectionManagerParams connParams = new HttpConnectionManagerParams();
		connParams.setConnectionTimeout(JCCTraySettings.getInstance().getInt(ISettingsConstants.HTTP_TIMEOUT));
		connParams.setSoTimeout(JCCTraySettings.getInstance().getInt(ISettingsConstants.HTTP_TIMEOUT));
		connectionManager.setParams(connParams);
		HttpClient client = new HttpClient(connectionManager);

		client.getParams().setAuthenticationPreemptive(true);
		if (!StringUtils.isEmptyOrNull(host.getHostName()) && !StringUtils.isEmptyOrNull(host.getPassword())){
			UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(host.getUsername(), host.getPassword());
			client.getState().setCredentials(new AuthScope(null, -1, null, null), credentials);
		}

		return client;
	}

	public void forceBuild(DashBoardProject project) throws Exception {
		HttpMethod method = httpMethod(project);
		try {
			if (executeMethod(method, project.getHost()) != HttpStatus.SC_OK)
				throw new Exception("There was an http error connecting to the server at "
						+ project.getHost().getHostName());
			if (!isInvokeSuccessful(method, project))
				throw new Exception(
						"The force build was not successful, the server did not return what JCCTray was expecting.");
		} finally {
			method.releaseConnection();
		}
	}

	/**
	 * Returns a {@link GetMethod} with some configuration set. Clients may
	 * override. Calls {@link #configureMethod(HttpMethod, DashBoardProject)} to
	 * configure the {@link HttpMethod} for the particular project.
	 *
	 * @param project
	 *            the project used to configure the {@link HttpMethod}
	 * @return a {@link GetMethod}
	 */
	protected HttpMethod httpMethod(DashBoardProject project) {
		HttpMethod method = new GetMethod(forceBuildURL(project));
		configureMethod(method, project);
		method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(3, false));
		return method;
	}

	protected void configureMethod(HttpMethod method, DashBoardProject project) {
		// do nothing
	}

	private boolean isInvokeSuccessful(HttpMethod method, DashBoardProject project) throws InvocationException {
		try {
			String message = getSuccessMessage(project);
			boolean invokeSuccessful = (method.getResponseBodyAsString().indexOf(message) > -1);
			if (!invokeSuccessful)
				getLog().error("Could not find the string '" + message + "' in the page located at " + method.getURI());
			return invokeSuccessful;
		} catch (IOException e) {
			getLog().error("Attempted to force the build, but the force was not successful", e);
			throw new InvocationException("Attempted to force the build, but the force was not successful", e);
		}
	}

	protected abstract String getSuccessMessage(DashBoardProject project);

	private int executeMethod(HttpMethod method, Host host) throws HTTPErrorException {
		try {
			int httpStatus = getClient(host).executeMethod(method);
			if (httpStatus != HttpStatus.SC_OK)
				getLog().error("Method failed: " + method.getStatusLine());
			return httpStatus;
		} catch (Exception e) {
			getLog()
					.error(
							"Could not force a build on project, either the webpage is not available, or there was a timeout in connecting to the cruise server.",
							e);
			throw new HTTPErrorException(
					"Could not force a build on project, either the webpage is not available, or there was a timeout in connecting to the cruise server.",
					e);
		}
	}

	protected abstract String forceBuildURL(DashBoardProject project);

	public DashBoardProjects getProjects(Host host) throws Exception {
		DashBoardProjects projects = DashboardXmlParser.getProjects(getXmlReportURL(host), getClient(host));
		for (int i = 0; i < projects.count(); i++)
			projects.getProject(i).setHost(host);
		return projects;
	}

	protected abstract String getXmlReportURL(Host host);

	protected Logger getLog() {
		return Logger.getLogger(getClass());
	}
}