else
client->elapsed = elapsed * 100;
- log_debug("XMT: Forming Solicit, %u ms elapsed.",
+ log_debug("XMT: Forming Solicit, %u0 ms elapsed.",
(unsigned)client->elapsed);
client->elapsed = htons(client->elapsed);
else
client->elapsed = elapsed * 100;
- log_debug("XMT: Forming Confirm, %u ms elapsed.",
+ log_debug("XMT: Forming Confirm, %u0 ms elapsed.",
(unsigned)client->elapsed);
client->elapsed = htons(client->elapsed);
else
client->elapsed = elapsed * 100;
- log_debug("XMT: Forming Request, %u ms elapsed.",
+ log_debug("XMT: Forming Request, %u0 ms elapsed.",
(unsigned)client->elapsed);
client->elapsed = htons(client->elapsed);
else
client->elapsed = elapsed * 100;
- log_debug("XMT: Forming %s, %u ms elapsed.",
+ log_debug("XMT: Forming %s, %u0 ms elapsed.",
dhcpv6_type_names[client->refresh_type],
(unsigned)client->elapsed);
/* Make sure that file descriptors 0 (stdin), 1, (stdout), and
2 (stderr) are open. To do this, we assume that when we
- open a file the lowest available file decriptor is used. */
+ open a file the lowest available file descriptor is used. */
fd = open("/dev/null", O_RDWR);
if (fd == 0)
fd = open("/dev/null", O_RDWR);
}
}
- /* XXX: temporary log for debuggin */
+ /* XXX: temporary log for debugging */
log_info("Packet received, but nothing done with it.");
}
#endif /* DHCPv6 */
return ISC_R_SUCCESS;
}
-/* Schedule updates to retry occaisionally until it no longer times out.
+/* Schedule updates to retry occasionally until it no longer times out.
*/
void
dhclient_schedule_updates(struct client_state *client, struct iaddr *addr,
* have a length field, unless it's a DHCPv6 zero-length
* options space (eg any of the enterprise-id'd options).
*
- * Zero-length-size option spaces basicaly consume the
+ * Zero-length-size option spaces basically consume the
* entire options buffer, so have at it.
*/
if (universe->get_length != NULL)
* If answering a client message, see whether any relay agent
* options were included with the message. If so, save them
* to copy back in later, and make space in the main buffer
- * to accomodate them
+ * to accommodate them
*/
if (client_state == NULL) {
priority_list[0] = DHO_DHCP_AGENT_OPTIONS;
memcpy(&buffer[index], agentopts, agent_size);
index += agent_size;
} else
- log_error("Unable to store relay agent information"
+ log_error("Unable to store relay agent information "
"in reply packet.");
}
length += encapsulation.len;
/* od.len can be nonzero if we got here without an
- * oc (cache lookup failed), but did have an enapculated
+ * oc (cache lookup failed), but did have an encapsulated
* simple encapsulation space.
*/
if (!od.len) {
break;
default:
- log_fatal("Inconstent universe tag size at %s:%d.", MDL);
+ log_fatal("Inconsistent universe tag size at %s:%d.", MDL);
}
option_code_hash_lookup(&option, universe->code_hash, &code, 0, MDL);
/* Save the contents of the option in a buffer. There are 3
* one-byte values we record from the packet, so we go ahead
- * and allocate a bigger buffer to accomodate them. But the
+ * and allocate a bigger buffer to accommodate them. But the
* 'length' we got (because it is a DNS encoded string) is
* one longer than we need...so we only add two extra octets.
*/
if ((upp + sizeof(udp)) > endbuf)
return -1;
- /* Copy the UDP header into a stack alined structure for inspection. */
+ /* Copy the UDP header into a stack aligned structure for inspection. */
memcpy(&udp, upp, sizeof(udp));
#ifdef USERLAND_FILTER
}
/*
- * Return true if every character in the string is hexidecimal.
+ * Return true if every character in the string is hexadecimal.
*/
static int
is_hex_string(const char *s) {
/* We can't actually free the name server structure,
because somebody might be hanging on to it. If
your /etc/resolv.conf file changes a lot, this
- could be a noticable memory leak. */
+ could be a noticeable memory leak. */
} else
sl = sp;
}
#ifdef DHCPv6
/*
* For both send_packet6() and receive_packet6() we need to use the
- * sendmsg()/recvmsg() functions rather than the simplier send()/recv()
+ * sendmsg()/recvmsg() functions rather than the simpler send()/recv()
* functions.
*
* In the case of send_packet6(), we need to do this in order to insure
* intents and purposes we only need to treat the entire field
* like a globally unique identifier (and if we create such an
* option, ensure the first 4 bytes are our enterprise-id followed
- * by a globlaly unique ID so long as you're within that enterprise
+ * by a globally unique ID so long as you're within that enterprise
* id). So we'll use "X" for now unless someone grumbles.
*/
{ "remote-id", "X", &dhcpv6_universe, 37, 1 },
{ "RECONFIGURE", 10 },
{ "INFORMATION-REQUEST", 11 },
{ "RELAY-FORW", 12 },
- { "RELY-REPL", 13 },
+ { "RELAY-REPL", 13 },
{ NULL, 0 }
};
* universe as they're configured - except during startup.
* Since we know how many we put down in .c files, we can
* allocate a more-than-right-sized buffer now, leaving some
- * space for user-configged option spaces.
+ * space for user-configured option spaces.
*
* 1: dhcp_universe (dhcpv4 options)
* 2: nwip_universe (dhcpv4 NWIP option)
&vsio_universe, MDL);
universe_hash_add(universe_hash, isc6_universe.name, 0,
&isc6_universe, MDL);
-/* This should not be neccessary. Listing here just for consistency.
+/* This should not be necessary. Listing here just for consistency.
* universe_hash_add(universe_hash, fqdn6_universe.name, 0,
* &fqdn6_universe, MDL);
*/
#ifndef LINT
-static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/dst_api.c,v 1.5 2007/09/05 17:32:10 dhankins Exp $";
+static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/dst_api.c,v 1.6 2007/11/30 21:51:43 fdupont Exp $";
#endif
/*
* This is the only file that needs to be changed if the crypto system is
* changed. Exported functions are:
* void dst_init() Initialize the toolkit
- * int dst_check_algorithm() Function to determines if alg is suppored.
+ * int dst_check_algorithm() Function to determines if alg is supported.
* int dst_compare_keys() Function to compare two keys for equality.
* int dst_sign_data() Incremental signing routine.
* int dst_verify_data() Incremental verify routine.
* KEY structure.
* int dst_key_to_dnskey() Function to return a public key in DNS
* format binary
- * DST_KEY *dst_buffer_to_key() Converst a data in buffer to KEY
- * int *dst_key_to_buffer() Writes out DST_KEY key matterial in buffer
+ * DST_KEY *dst_buffer_to_key() Convert a data in buffer to KEY
+ * int *dst_key_to_buffer() Writes out DST_KEY key material in buffer
* void dst_free_key() Releases all memory referenced by key structure
*/
* The location to which the signature will be written.
* sig_len Length of the signature field in bytes.
* Return
- * 0 Successfull INIT or Update operation
+ * 0 Successful INIT or Update operation
* >0 success FINAL (sign) operation
* <0 failure
*/
* in_id The id of the private key.
* options DST_FORCE_READ Read from disk - don't use a previously
* read key.
- * DST_CAN_SIGN The key must be useable for signing.
- * DST_NO_AUTHEN The key must be useable for authentication.
+ * DST_CAN_SIGN The key must be usable for signing.
+ * DST_NO_AUTHEN The key must be usable for authentication.
* DST_STANDARD Return any key
* Returns
* NULL If there is no key found in the current directory or
DST_KEY *dg_key = NULL, *pubkey = NULL;
if (!dst_check_algorithm(in_alg)) { /* make sure alg is available */
- EREPORT(("dst_read_private_key(): Algorithm %d not suppored\n",
+ EREPORT(("dst_read_private_key(): Algorithm %d not supported\n",
in_alg));
return (NULL);
}
if (key == NULL)
return (0);
if (!dst_check_algorithm(key->dk_alg)) { /* make sure alg is available */
- EREPORT(("dst_write_key(): Algorithm %d not suppored\n",
+ EREPORT(("dst_write_key(): Algorithm %d not supported\n",
key->dk_alg));
return (UNSUPPORTED_KEYALG);
}
* filename of the key file to be read.
* Returns
* NULL If the key does not exist or no name is supplied.
- * NON-NULL Initalized key structure if the key exists.
+ * NON-NULL Initialized key structure if the key exists.
*/
static DST_KEY *
while ((c = getc(fp)) != EOF)
if (!isspace(c))
break;
- ungetc(c, fp); /* return the charcter to the input field */
+ ungetc(c, fp); /* return the character to the input field */
/* Handle hex!! FIXME. */
if (fscanf(fp, "%d %d %d", &flags, &proto, &alg) != 3) {
* dst_dnskey_to_public_key
* This function converts the contents of a DNS KEY RR into a DST
* key structure.
- * Paramters
+ * Parameters
* len Length of the RDATA of the KEY RR RDATA
* rdata A pointer to the the KEY RR RDATA.
* in_name Key name to be stored in key structure.
return (NULL);
alg = (u_int8_t) rdata[DST_KEY_ALG];
if (!dst_check_algorithm(alg)) { /* make sure alg is available */
- EREPORT(("dst_dnskey_to_key(): Algorithm %d not suppored\n",
+ EREPORT(("dst_dnskey_to_key(): Algorithm %d not supported\n",
alg));
return (NULL);
}
start += 2;
}
/*
- * now point to the begining of the data representing the encoding
+ * now point to the beginning of the data representing the encoding
* of the key
*/
if (key_st->dk_func && key_st->dk_func->from_dns_key) {
len - start) > 0)
return (key_st);
} else
- EREPORT(("dst_dnskey_to_public_key(): unsuppored alg %d\n",
+ EREPORT(("dst_dnskey_to_public_key(): unsupported alg %d\n",
alg));
SAFE_FREE(key_st);
return (-1);
if (!dst_check_algorithm(key->dk_alg)) { /* make sure alg is available */
- EREPORT(("dst_key_to_dnskey(): Algorithm %d not suppored\n",
+ EREPORT(("dst_key_to_dnskey(): Algorithm %d not supported\n",
key->dk_alg));
return (UNSUPPORTED_KEYALG);
}
DST_KEY *dkey = NULL;
if (!dst_check_algorithm(alg)) { /* make sure alg is available */
- EREPORT(("dst_buffer_to_key(): Algorithm %d not suppored\n", alg));
+ EREPORT(("dst_buffer_to_key(): Algorithm %d not supported\n", alg));
return (NULL);
}
dst_key_to_buffer(DST_KEY *key, u_char *out_buff, unsigned buf_len)
{
int len;
- /* this function will extrac the secret of HMAC into a buffer */
+ /* this function will extract the secret of HMAC into a buffer */
if(key == NULL)
return (0);
if(key->dk_func != NULL && key->dk_func != NULL) {
* pk_key Structure that the key is returned in.
* in_id Key identifier (tag)
* Return
- * 1 if everthing works
+ * 1 if everything works
* 0 if there is any problem
*/
return (NULL);
if (!dst_check_algorithm(alg)) { /* make sure alg is available */
- EREPORT(("dst_generate_key(): Algorithm %d not suppored\n", alg));
+ EREPORT(("dst_generate_key(): Algorithm %d not supported\n", alg));
return (NULL);
}
/*
* dst_sig_size
- * Return the maximim size of signature from the key specified in bytes
+ * Return the maximum size of signature from the key specified in bytes
* Parameters
* key
* Returns
unsigned dk_flags; /* and the flags of the public key */
unsigned dk_id; /* identifier of the key */
void *dk_KEY_struct; /* pointer to key in crypto pkg fmt */
- struct dst_func *dk_func; /* point to cryptto pgk specific function table */
+ struct dst_func *dk_func; /* point to crypto pgk specific function table */
} DST_KEY;
#define HAS_DST_KEY
#include <isc-dhcp/dst.h>
/*
* define what crypto systems are supported for RSA,
- * BSAFE is prefered over RSAREF; only one can be set at any time
+ * BSAFE is preferred over RSAREF; only one can be set at any time
*/
#if defined(BSAFE) && defined(RSAREF)
# error "Cannot have both BSAFE and RSAREF defined"
-static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/dst_support.c,v 1.2 2007/10/27 19:15:32 each Exp $";
+static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/dst_support.c,v 1.3 2007/11/30 21:51:43 fdupont Exp $";
/*
* byte order conversion.
* Parameters
* buf Pointer to encoded input string. Pointer is updated if
- * function is successfull.
+ * function is successful.
* loc Output area.
* loclen Size in bytes of output area.
* Return
}
/*
- * dst_s_dns_key_id() Function to calculated DNSSEC footprint from KEY reocrd
+ * dst_s_dns_key_id() Function to calculated DNSSEC footprint from KEY record
* rdata (all of record)
* Input:
* dns_key_rdata: the raw data in wire format
* rdata_len: the size of the input data
* Output:
- * the key footprint/id calcuated from the key data
+ * the key footprint/id calculated from the key data
*/
u_int16_t
dst_s_dns_key_id(const u_char *dns_key_rdata, const unsigned rdata_len)
#ifdef HMAC_MD5
#ifndef LINT
-static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/hmac_link.c,v 1.1 2001/02/22 07:22:08 mellon Exp $";
+static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/hmac_link.c,v 1.2 2007/11/30 21:51:43 fdupont Exp $";
#endif
/*
* Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc.
/*
* dst_hmac_md5_to_dns_key()
* function to extract hmac key from DST_KEY structure
- * intput:
+ * input:
* in_key: HMAC-MD5 key
* output:
* out_str: buffer to write ot
unsigned char *MD5();
#endif
-/* to provide backward compatabilty to RSAREF calls ogud@tis.com 1997/11/14 */
+/* to provide backward compatibleness to RSAREF calls ogud@tis.com 1997/11/14 */
#define MD5Init(c) MD5_Init(c)
#define MD5Update(c,data, len) MD5_Update(c,data,len)
#define MD5Final(md, c) MD5_Final(md, c)
static unsigned char end[4]={0x80,0x00,0x00,0x00};
unsigned char *cp=end;
- /* c->num should definitly have room for at least one more byte. */
+ /* c->num should definitely have room for at least one more byte. */
p=c->data;
j=c->num;
i=j>>2;
*/
/* As pointed out by Wei Dai <weidai@eskimo.com>, the above can be
- * simplified to the code below. Wei attributes these optimisations
+ * simplified to the code below. Wei attributes these optimizations
* to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
*/
#define F(x,y,z) ((((y) ^ (z)) & (x)) ^ (z))
#ifndef LINT
-static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/prandom.c,v 1.5 2007/09/05 17:32:10 dhankins Exp $";
+static const char rcsid[] = "$Header: /tmp/cvstest/DHCP/dst/prandom.c,v 1.6 2007/11/30 21:51:43 fdupont Exp $";
#endif
/*
* Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc.
#endif
/*
- * the constant below is a prime number to make fixed data structues like
- * stat and time wrap over blocks. This adds certain uncertanty to what is
+ * the constant below is a prime number to make fixed data structures like
+ * stat and time wrap over blocks. This adds certain randomness to what is
* in each digested block.
* The prime number 2879 has the special property that when
* divided by 2,4 and 6 the result is also a prime numbers
#endif
/*
- * This constant dictatates how many bits we shift to the right before using a
+ * This constant dictates how many bits we shift to the right before using a
*/
#ifndef DST_SHIFT
#define DST_SHIFT 9
#endif
/*
- * An initalizer that is as bad as any other with half the bits set
+ * An initializer that is as bad as any other with half the bits set
*/
#ifndef DST_RANDOM_PATTERN
#define DST_RANDOM_PATTERN 0x8765CA93
/*
* these two data structure are used to process input data into digests,
*
- * The first structure is containts a pointer to a DST HMAC key
+ * The first structure contains a pointer to a DST HMAC key
* the variables accompanying are used for
* step : select every step byte from input data for the hash
* block: number of data elements going into each hash
} prand_hash;
/*
- * This data structure controlls number of hashes and keeps track of
+ * This data structure controls number of hashes and keeps track of
* overall progress in generating correct number of bytes of output.
* output : array to store the output data in
* needed : how many bytes of output are needed
/*
* setting the quick_random generator to particular values or if both
- * input parameters are 0 then set it to initial vlaues
+ * input parameters are 0 then set it to initial values
*/
void
*
* do_ls() does not visit subdirectories
* if attacker has access to machine it can guess most of the values seen
- * thus it is important to only visit directories that are freqently updated
+ * thus it is important to only visit directories that are frequently updated
* Attacker that has access to the network can see network traffic
* when NFS mounted directories are accessed and know exactly the data used
* but may not know exactly in what order data is used.
file_name[dir_len + len] = 0x0;
/* for all entries in dir get the stats */
if (stat(file_name, &buf) == 0) {
- n++; /* count successfull stat calls */
+ n++; /* count successful stat calls */
/* copy non static fields */
dir_info.uid += buf.st_uid;
dir_info.gid += buf.st_gid;
/*
* if more than half a block then add data to output
- * otherwise adde the digest to the next hash
+ * otherwise add the digest to the next hash
*/
if ((hash->digested * 2) > hash->block) {
i = dst_sign_data(SIG_MODE_FINAL, hash->key, &hash->ctx,
/*
* This function takes the input data does the selection of data specified
* by the hash control block.
- * The step varialbe in the work sturcture determines which 1/step bytes
+ * The step variable in the work structure determines which 1/step bytes
* are used,
*
*/
tmp = tp;
for (cnt = 0, i = hash->curr; i < size; i += hash->step, cnt++)
*(tp++) = input[i];
- /* calcutate the starting point in the next input set */
+ /* calculate the starting point in the next input set */
hash->curr = (hash->step - (i - size)) % hash->step;
}
/* digest the data in block sizes */
/*
* this function gets some semi random data and sets that as an HMAC key
- * If we get a valid key this function returns that key initalized
+ * If we get a valid key this function returns that key initialized
* otherwise it returns NULL;
*/
static prand_hash *
if (buff == NULL)
return (NULL);
/* do not memset the allocated memory to get random bytes there */
- /* time of day is somewhat random expecialy in the last bytes */
+ /* time of day is somewhat random especially in the last bytes */
gettimeofday((struct timeval *) &buff[n], NULL);
n += sizeof(struct timeval);
* This function goes out and from various sources tries to generate enough
* semi random data that a hash function can generate a random data.
* This function will iterate between the two main random source sources,
- * information from programs and directores in random order.
+ * information from programs and directories in random order.
* This function return the number of bytes added to the random output buffer.
*/
static unsigned
* of randomness to the caller it will use the best available sources of
* randomness.
* The current order is to use /dev/random, precalculated randomness, and
- * finaly use some system calls and programs to generate semi random data that
- * is then digested to generate randomness.
+ * finally use some system calls and programs to generate semi random data
+ * that is then digested to generate randomness.
* This function is thread safe as each thread uses its own context, but
* concurrent treads will affect each other as they update shared state
* information.
* that is not a multiple of the output of the hash function used.
*
* If /dev/random is not available this function is not suitable to generate
- * large ammounts of data, rather it is suitable to seed a pseudo-random
+ * large amounts of data, rather it is suitable to seed a pseudo-random
* generator
* Returns the number of bytes put in the output buffer
*/
* counters that is incremented between digest operations
* each increment operation amortizes to 2 bits changed in that value
* for 5 counters thus the input will amortize to have 10 bits changed
- * The counters are initaly set using the strong random function above
- * the HMAC key is selected by the same methold as the HMAC keys for the
+ * The counters are initially set using the strong random function above
+ * the HMAC key is selected by the same method as the HMAC keys for the
* strong random function.
* Each set of counters is used for 2^25 operations
*
semi_loc += out;
}
}
-/* generate more randome stuff */
+/* generate more random stuff */
while (out < size) {
/*
* modify at least one bit by incrementing at least one counter
* based on the last bit of the last counter updated update
* the next one.
- * minimaly this operation will modify at least 1 bit,
+ * minimally this operation will modify at least 1 bit,
* amortized 2 bits
*/
for (n = 0; n < DST_NUMBER_OF_COUNTERS; n++)
#include <omapip/omapip_p.h>
#if !defined (BYTE_NAME_HASH_SIZE)
-# define BYTE_NAME_HASH_SIZE 401 /* Default would be rediculous. */
+# define BYTE_NAME_HASH_SIZE 401 /* Default would be ridiculous. */
#endif
#if !defined (BYTE_CODE_HASH_SIZE)
-# define BYTE_CODE_HASH_SIZE 254 /* Default would be rediculous. */
+# define BYTE_CODE_HASH_SIZE 254 /* Default would be ridiculous. */
#endif
/* Although it is highly improbable that a 16-bit option space might
#endif
/* Not only is it improbable that the 32-bit spaces might actually use 2^32
- * defined options, it is infeasable. It would be best for this kind of
+ * defined options, it is infeasible. It would be best for this kind of
* space to be dynamically sized. Instead we size it at the word hash's
* level.
*/
#endif
#if !defined (FQDN_HASH_SIZE)
-# define FQDN_HASH_SIZE 13 /* A rediculously small table. */
+# define FQDN_HASH_SIZE 13 /* A ridiculously small table. */
#endif
/* I really doubt a given installation is going to have more than a few
/* omapi_io_destroy (object, MDL);
*
- * Find the requsted IO [object] and remove it from the list of io
+ * Find the requested IO [object] and remove it from the list of io
* states, causing the cleanup functions to destroy it. Note that we must
* hold a reference on the object while moving its ->next reference and
* removing the reference in the chain to the target object...otherwise it
/* Make sure that file descriptors 0 (stdin), 1, (stdout), and
2 (stderr) are open. To do this, we assume that when we
- open a file the lowest available file decriptor is used. */
+ open a file the lowest available file descriptor is used. */
fd = open("/dev/null", O_RDWR);
if (fd == 0)
fd = open("/dev/null", O_RDWR);
}
/* lease-file :== lease-declarations END_OF_FILE
- lease-statments :== <nil>
+ lease-statements :== <nil>
| lease-declaration
| lease-declarations lease-declaration */
token = next_token(&val, NULL, cfile);
if (token != OPTION) {
parse_warn(cfile,
- "host-identifer must be an option");
+ "host-identifier must be an option");
skip_to_rbrace(cfile, 1);
break;
}
break;
/* RESERVED and BOOTP states preserved for
- * compatiblity with older versions.
+ * compatibleness with older versions.
*/
case TOKEN_RESERVED:
new_state = FTS_ACTIVE;
* server-duid llt ethernet|ieee802|fddi 213982198 00:16:6F:49:7D:9B;
* server-duid ll;
* server-duid ll ethernet|ieee802|fddi 00:16:6F:49:7D:9B;
- * server-duid en 2495 "enterprise-specific-identifer-1234";
+ * server-duid en 2495 "enterprise-specific-identifier-1234";
*/
void
parse_server_duid_conf(struct parse *cfile) {
/* Make sure that file descriptors 0 (stdin), 1, (stdout), and
2 (stderr) are open. To do this, we assume that when we
- open a file the lowest available file decriptor is used. */
+ open a file the lowest available file descriptor is used. */
fd = open("/dev/null", O_RDWR);
if (fd == 0)
fd = open("/dev/null", O_RDWR);
struct lease *lease;
int want_associated_ip;
int assoc_ip_cnt;
- u_int32_t assoc_ips[40]; /* XXXSK: arbritrary maximum number of IPs */
+ u_int32_t assoc_ips[40]; /* XXXSK: arbitrary maximum number of IPs */
const int nassoc_ips = sizeof(assoc_ips) / sizeof(assoc_ips[0]);
unsigned char dhcpMsgType;
allow_leasequery = 0;
/*
- * See if we are authorised to do LEASEQUERY.
+ * See if we are authorized to do LEASEQUERY.
*/
oc = lookup_option(&server_universe, options, SV_LEASEQUERY);
if (oc != NULL) {
*/
u_int32_t renew, rebind, prefer, valid;
- /* Client-rqeuested valid and preferred lifetimes. */
+ /* Client-requested valid and preferred lifetimes. */
u_int32_t client_valid, client_prefer;
/* Chosen values to transmit for valid and preferred lifetimes. */
u_int32_t send_valid, send_prefer;
- /* Index into the data field that has been sonsumed. */
+ /* Index into the data field that has been consumed. */
unsigned cursor;
union reply_buffer {
* reply that contains all that we know about the client's correct lease
* (or projected lease).
*
- * Solicit - "Soft" binding, ignore uknown addresses or bindings, just
+ * Solicit - "Soft" binding, ignore unknown addresses or bindings, just
* send what we "may" give them on a request.
*
* Request - "Hard" binding, but ignore supplied addresses (just provide what
reply->opt_state,
scope, oc, MDL) ||
(data.len != 4)) {
- log_error("reply_process_ia: uanble to "
+ log_error("reply_process_ia: unable to "
"evaluate default lease time");
status = ISC_R_FAILURE;
goto cleanup;
* XXX: case where a client first identifies itself using vendor
* XXX: options in a solicit, or request, but later neglects to include
* XXX: these options in a Renew or Rebind. It is not clear that this
- * XXX: is required, and has some startling ramnifications (such as
+ * XXX: is required, and has some startling ramifications (such as
* XXX: how to recover this dynamic host {} state across restarts).
*/
if (reply->host != NULL)
/* Now append the lease. */
data.len = IAADDR_OFFSET;
if (!buffer_allocate(&data.buffer, data.len, MDL)) {
- log_error("reply_process_ia: out of memory alloating "
+ log_error("reply_process_ia: out of memory allocating "
"new IAADDR buffer.");
status = ISC_R_NOMEMORY;
goto cleanup;
* address we gave it.
*
* Since we're only dealing with fixed leases for now, there's not
- * much we can do, other that log the occurrance.
+ * much we can do, other that log the occurrence.
*
* When we start issuing addresses from pools, then we will have to
* record our declined addresses and issue another. In general with
struct data_string interface_id;
/*
- * Intialize variables for early exit.
+ * Initialize variables for early exit.
*/
memset(&enc_opt_data, 0, sizeof(enc_opt_data));
enc_packet = NULL;
specified for each failover object, there could be as many as one
listener object for each secondary failover_state object. */
-/* This, then, is the implemention of the failover link object. */
+/* This, then, is the implementation of the failover link object. */
isc_result_t dhcp_failover_link_initiate (omapi_object_t *h)
{
break;
/* If we're in communications-interrupted and an
- amnesiac peer connects, go to the partner_down
+ amnesic peer connects, go to the partner_down
state immediately. */
case recover:
dhcp_failover_set_state (state, partner_down);
if (!state -> link_to_peer)
return ISC_R_SUCCESS;
- /* If there are acks pending, transmit them prior to potentialy
+ /* If there are acks pending, transmit them prior to potentially
* sending new updates for the same lease.
*/
if (state->toack_queue_head != NULL)
write_lease(lease);
/* Commit the lease only after a two-second timeout,
so that if we get a bunch of acks in quick
- successtion (e.g., when stealing leases from the
+ succession (e.g., when stealing leases from the
secondary), we do not do an immediate commit for
each one. */
add_timeout(cur_time + 2,
hd->host_id_option, MDL);
if (!host_new_hash(&h_id_info->values_hash,
HOST_HASH_SIZE, MDL)) {
- log_fatal("No memory for host-identifer "
+ log_fatal("No memory for host-identifier "
"option hash.");
}
h_id_info->next = host_id_info;
just_move_it:
#if defined (FAILOVER_PROTOCOL)
/* Atsfp should be cleared upon any state change that implies
- * propogation whether supersede_lease was given a copy lease
+ * propagation whether supersede_lease was given a copy lease
* structure or not (often from the pool_timer()).
*/
if (propogate)
}
/* This only works during server startup: during runtime, the last
- * lease may be dequeued inbetween calls. If the queue is the same
+ * lease may be dequeued in between calls. If the queue is the same
* as was used previously, and the lease structure isn't (this is not
* a re-queue), use that as a starting point for the insertion-sort.
*/
projects / thirdparty / dhcp.git / commitdiff
