nut-debian/debian/patches/0001-fix_spelling_and_typo.patch

--- a/docs/man/dummy-ups.txt (revision 2722)
+++ b/docs/man/dummy-ups.txt (revision 2882)
@@ -56,5 +56,5 @@
 This file is generally named "something.dev". It contains a list of all
 valid data and associated values, and has the same format as an linkman:upsc[8]
-dump (<varname>: <value>). So you can easilly create definition
+dump (<varname>: <value>). So you can easily create definition
 files from an existing UPS using "upsc > file.dev".
 It can also be empty, in which case only a basic set of data is available:
--- a/docs/man/metasys.txt (revision 2722)
+++ b/docs/man/metasys.txt (revision 2882)
@@ -45,5 +45,5 @@
 ally HF 1000 only.
 
-Any informations about the use of the driver with the other listed
+Any information about the use of the driver with the other listed
 UPS are really welcome.
 
--- a/drivers/apcsmart.c (revision 2596)
+++ b/drivers/apcsmart.c (revision 2882)
@@ -325,5 +325,5 @@
 		   this if the REQ_CAPABILITIES command is supported
 		*/
-		upslogx(LOG_ERR, "ERROR: APC cannot do capabilites but said it could!");
+		upslogx(LOG_ERR, "ERROR: APC cannot do capabilities but said it could!");
 		return;
 	}
--- a/drivers/dummy-ups.c (revision 2699)
+++ b/drivers/dummy-ups.c (revision 2882)
@@ -376,5 +376,5 @@
 	 * the update / sync process (with cmdvartab?!) */
 
-	upsdebugx(1, "Unknown data. Commiting anyway...");
+	upsdebugx(1, "Unknown data. Committing anyway...");
 	return 1;
 	/* return 0;*/
@@ -396,5 +396,5 @@
 	 * the update / sync process (with cmdvartab?) */
 
-	upsdebugx(1, "Unknown data. Commiting value anyway...");
+	upsdebugx(1, "Unknown data. Committing value anyway...");
 	return 1;
 	/* return 0;*/
--- a/drivers/snmp-ups.c (revision 2757)
+++ b/drivers/snmp-ups.c (revision 2882)
@@ -485,5 +485,5 @@
 		break;
 	default:
-		upslogx(LOG_ERR, "[%s] unhandled ASN 0x%x recieved from %s",
+		upslogx(LOG_ERR, "[%s] unhandled ASN 0x%x received from %s",
 			upsname?upsname:device_name, pdu->variables->type, OID);
 		return FALSE;
@@ -525,5 +525,5 @@
 		break;
 	default:
-		upslogx(LOG_ERR, "[%s] unhandled ASN 0x%x recieved from %s",
+		upslogx(LOG_ERR, "[%s] unhandled ASN 0x%x received from %s",
 			upsname?upsname:device_name, pdu->variables->type, OID);
 		return FALSE;
@@ -1460,5 +1460,5 @@
 			upslogx(LOG_ERR, "su_setvar: cannot set value %s for %s", arg[4], arg[3]);
 		else
-			upsdebugx(1, "su_setvar: sucessfully set %s to \"%s\"", arg[0], arg[4]);
+			upsdebugx(1, "su_setvar: successfully set %s to \"%s\"", arg[0], arg[4]);
 
 		return 1;
--- a/drivers/genericups.c (revision 2336)
+++ b/drivers/genericups.c (revision 2882)
@@ -143,10 +143,10 @@
 	if ((v = getval("OL")) != NULL) {
 		parse_input_signals(v, &upstab[upstype].line_ol, &upstab[upstype].val_ol);
-		upsdebugx(2, "parse_input_signals: OL overriden with %s\n", v);
+		upsdebugx(2, "parse_input_signals: OL overridden with %s\n", v);
 	}
 
 	if ((v = getval("LB")) != NULL) {
 		parse_input_signals(v, &upstab[upstype].line_bl, &upstab[upstype].val_bl);
-		upsdebugx(2, "parse_input_signals: LB overriden with %s\n", v);
+		upsdebugx(2, "parse_input_signals: LB overridden with %s\n", v);
 	}
 }
@@ -319,10 +319,10 @@
 	if ((v = getval("CP")) != NULL) {
 		parse_output_signals(v, &upstab[upstype].line_norm);
-		upsdebugx(2, "parse_output_signals: CP overriden with %s\n", v);
+		upsdebugx(2, "parse_output_signals: CP overridden with %s\n", v);
 	}
 
 	if ((v = getval("SD")) != NULL) {
 		parse_output_signals(v, &upstab[upstype].line_sd);
-		upsdebugx(2, "parse_output_signals: SD overriden with %s\n", v);
+		upsdebugx(2, "parse_output_signals: SD overridden with %s\n", v);
 	}
 
--- a/drivers/metasys.c (revision 2601)
+++ b/drivers/metasys.c (revision 2882)
@@ -63,10 +63,10 @@
 /*
 	Metasystem UPS data transfer are made with packet of the format:
-	STX		DATA_LENGHT		DATA		CHECKSUM
+	STX		DATA_LENGTH		DATA		CHECKSUM
 	where:
 	STX is 0x02 and is the start of transmission byte
-	DATA_LENGHT is number of data bytes + the checksum byte
+	DATA_LENGTH is number of data bytes + the checksum byte
 	DATA ......
-	CHECKSUM is the sum modulus 256 of all DATA bytes + DATA_LENGHT
+	CHECKSUM is the sum modulus 256 of all DATA bytes + DATA_LENGTH
 	
 	The answer from the UPS have the same packet format and the first
@@ -115,5 +115,5 @@
 
 /* send a read command to the UPS, it retries 5 times before give up
-   it's a 4 byte request (STX, LENGHT, COMMAND and CHECKSUM) */
+   it's a 4 byte request (STX, LENGTH, COMMAND and CHECKSUM) */
 void send_read_command(char command) {
 	int retry, sent;
@@ -123,7 +123,7 @@
 	while ((sent != 4) && (retry < 5)) {
 		buf[0]=0x02; 			/* STX Start of Transmission */
-		buf[1]=0x02;			/* data lenght(data + checksum byte) */
+		buf[1]=0x02;			/* data length(data + checksum byte) */
 		buf[2]=command;			/* command to send */
-		buf[3]=buf[1] + buf[2];	/* checksum (sum modulus 256 of data bytes + lenght) */
+		buf[3]=buf[1] + buf[2];	/* checksum (sum modulus 256 of data bytes + length) */
 		if (retry == 4) send_zeros();	/* last retry is preceded by a serial reset...*/
 		sent = ser_send_buf(upsfd, buf, 4);
@@ -135,5 +135,5 @@
    with a char* buffer 
    it retries 5 times before give up */
-void send_write_command(unsigned char *command, int command_lenght) {
+void send_write_command(unsigned char *command, int command_length) {
 	int i, retry, sent, checksum;
 	unsigned char raw_buf[255];
@@ -141,21 +141,21 @@
 	/* prepares the raw data */
 	raw_buf[0] = 0x02;		/* STX byte */
-	raw_buf[1] = (unsigned char)(command_lenght + 1);		/* data lenght + checksum */
-	memcpy(raw_buf+2, command, command_lenght);
-	command_lenght += 2;
+	raw_buf[1] = (unsigned char)(command_length + 1);		/* data length + checksum */
+	memcpy(raw_buf+2, command, command_length);
+	command_length += 2;
 	
 	/* calculate checksum */
 	checksum = 0;
-	for (i = 1; i < command_lenght; i++) checksum += raw_buf[i];
+	for (i = 1; i < command_length; i++) checksum += raw_buf[i];
 	checksum = checksum % 256;
-	raw_buf[command_lenght] = (unsigned char)checksum;
-	command_lenght +=1;
+	raw_buf[command_length] = (unsigned char)checksum;
+	command_length +=1;
 	
 	retry = 0;
 	sent = 0;
-	while ((sent != (command_lenght)) && (retry < 5)) {
+	while ((sent != (command_length)) && (retry < 5)) {
 		if (retry == 4) send_zeros();	/* last retry is preceded by a serial reset... */
-		sent = ser_send_buf(upsfd, raw_buf, (command_lenght));
-		if (sent != (command_lenght)) printf("Error sending command %d\n", raw_buf[2]);
+		sent = ser_send_buf(upsfd, raw_buf, (command_length));
+		if (sent != (command_length)) printf("Error sending command %d\n", raw_buf[2]);
 		retry += 1;
 	}	
@@ -165,6 +165,6 @@
 /* get the answer of a command from the ups */
 int get_answer(unsigned char *data) {
-	unsigned char my_buf[255];	/* packet has a maximum lenght of 256 bytes */
-	int packet_lenght, checksum, i, res;
+	unsigned char my_buf[255];	/* packet has a maximum length of 256 bytes */
+	int packet_length, checksum, i, res;
 	/* Read STX byte */
 	res = ser_get_char(upsfd, my_buf, 1, 0);
@@ -177,41 +177,41 @@
 		return -1;	
 	}
-	/* Read data lenght byte */
+	/* Read data length byte */
 	res = ser_get_char(upsfd, my_buf, 1, 0);
 	if (res < 1) {
-		ser_comm_fail("Receive error (lenght): %d!!!\n", res);
+		ser_comm_fail("Receive error (length): %d!!!\n", res);
 		return -1;	
 	}
-	packet_lenght = my_buf[0];
-	if (packet_lenght < 2) {
-		ser_comm_fail("Receive error (lenght): packet lenght %d!!!\n", packet_lenght);
+	packet_length = my_buf[0];
+	if (packet_length < 2) {
+		ser_comm_fail("Receive error (length): packet length %d!!!\n", packet_length);
 		return -1;	
 	}
-	/* Try to read all the remainig bytes (packet_lenght) */
-	res = ser_get_buf_len(upsfd, my_buf, packet_lenght, 1, 0);
-	if (res != packet_lenght) {
-		ser_comm_fail("Receive error (data): got %d bytes instead of %d!!!\n", res, packet_lenght);
+	/* Try to read all the remainig bytes (packet_length) */
+	res = ser_get_buf_len(upsfd, my_buf, packet_length, 1, 0);
+	if (res != packet_length) {
+		ser_comm_fail("Receive error (data): got %d bytes instead of %d!!!\n", res, packet_length);
 		return -1;	
 	}
 		
 	/* now we have the whole answer from the ups, we can checksum it 
-	   checksum byte is equal to the sum modulus 256 of all the data bytes + packet_lenght 
+	   checksum byte is equal to the sum modulus 256 of all the data bytes + packet_length
 	   (no STX no checksum byte itself) */
-	checksum = packet_lenght;
-	for (i = 0; i < (packet_lenght - 1); i++) checksum += my_buf[i];  
+	checksum = packet_length;
+	for (i = 0; i < (packet_length - 1); i++) checksum += my_buf[i];  
 	checksum = checksum % 256;
-	if (my_buf[packet_lenght-1] != checksum) {
-		ser_comm_fail("checksum error! got %x instad of %x, received %d bytes \n", my_buf[packet_lenght - 1], checksum, packet_lenght);
-		dump_buffer(my_buf, packet_lenght);
+	if (my_buf[packet_length-1] != checksum) {
+		ser_comm_fail("checksum error! got %x instad of %x, received %d bytes \n", my_buf[packet_length - 1], checksum, packet_length);
+		dump_buffer(my_buf, packet_length);
 		return -1;
 	}
-	packet_lenght-=1;		/* get rid of the checksum byte */
-	memcpy(data, my_buf, packet_lenght);
-	return packet_lenght;
+	packet_length-=1;		/* get rid of the checksum byte */
+	memcpy(data, my_buf, packet_length);
+	return packet_length;
 }
 
 /* send a read command and try get the answer, if something fails, it retries (5 times max)
    if it is on the 4th or 5th retry, it will flush the serial before sending commands
-   it returns the lenght of the received answer or -1 in case of failure */
+   it returns the length of the received answer or -1 in case of failure */
 int command_read_sequence(unsigned char command, unsigned char *data) {
 	int bytes_read = 0;
@@ -235,11 +235,11 @@
 /* send a write command and try get the answer, if something fails, it retries (5 times max)
    if it is on the 4th or 5th retry, it will flush the serial before sending commands
-   it returns the lenght of the received answer or -1 in case of failure */
-int command_write_sequence(unsigned char *command, int command_lenght, unsigned char *answer) {
+   it returns the length of the received answer or -1 in case of failure */
+int command_write_sequence(unsigned char *command, int command_length, unsigned char *answer) {
 	int bytes_read = 0;
 	int retry = 0;
 	
 	while ((bytes_read < 1) && (retry < 5)) {
-		send_write_command(command, command_lenght);
+		send_write_command(command, command_length);
 		bytes_read = get_answer(answer);
 		if (retry > 2) ser_flush_in(upsfd, "", 0);