Get rid of some rcsid blocks. The EDK II build options cause a build break on the rcsid definitions. It is easier to delete them than other workarounds.

Fix case mismatch for an included file.


git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@12092 6f19259b-4bc3-4df7-8a09-765794883524

4 files changed, 241 insertions, 246 deletions

diff --git a/StdLib/BsdSocketLib/SocketInternals.h b/StdLib/BsdSocketLib/SocketInternals.h
index 57eed94f3c..4f5c584a4e 100644
--- a/StdLib/BsdSocketLib/SocketInternals.h
+++ b/StdLib/BsdSocketLib/SocketInternals.h
@@ -25,7 +25,7 @@
 #include <kfile.h>

 #include <MainData.h>

 

-#include <efi/SysEfi.h>

+#include <Efi/SysEfi.h>

 

 //

 //  End of private files

@@ -118,7 +118,7 @@ BslSocketPoll (
   Build a file descriptor for a socket.

 

   @param [in] pSocketProtocol   Socket protocol structure address

-  

+

   @param [in] pErrno            Address of the errno variable

 

   @returns The file descriptor for the socket or -1 if an error occurs.

diff --git a/StdLib/BsdSocketLib/accept.c b/StdLib/BsdSocketLib/accept.c
index 3dbfe97013..de8d91f607 100644
--- a/StdLib/BsdSocketLib/accept.c
+++ b/StdLib/BsdSocketLib/accept.c
@@ -12,7 +12,7 @@
 

 **/

 

-#include <SocketInternals.h>

+#include "SocketInternals.h"

 

 

 /**

@@ -60,7 +60,7 @@ AcceptWork (
     //

     // TODO: Update bBlocking by anding with check for NON_BLOCKING

     //

-    

+

     //

     //  Attempt to accept a new network connection

     //

diff --git a/StdLib/BsdSocketLib/base64.c b/StdLib/BsdSocketLib/base64.c
index 593360535c..d8c588d19d 100644
--- a/StdLib/BsdSocketLib/base64.c
+++ b/StdLib/BsdSocketLib/base64.c
@@ -44,28 +44,28 @@
  * Portions copyright (c) 1999, 2000

  * Intel Corporation.

  * All rights reserved.

- * 

+ *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions

  * are met:

- * 

+ *

  * 1. Redistributions of source code must retain the above copyright

  *    notice, this list of conditions and the following disclaimer.

- * 

+ *

  * 2. Redistributions in binary form must reproduce the above copyright

  *    notice, this list of conditions and the following disclaimer in the

  *    documentation and/or other materials provided with the distribution.

- * 

+ *

  * 3. All advertising materials mentioning features or use of this software

  *    must display the following acknowledgement:

- * 

+ *

  *    This product includes software developed by Intel Corporation and

  *    its contributors.

- * 

+ *

  * 4. Neither the name of Intel Corporation or its contributors may be

  *    used to endorse or promote products derived from this software

  *    without specific prior written permission.

- * 

+ *

  * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS''

  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

@@ -77,13 +77,10 @@
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

  * THE POSSIBILITY OF SUCH DAMAGE.

- * 

+ *

+  base64.c,v 1.1.1.1 2003/11/19 01:51:25 kyu3 Exp

  */

 

-#if !defined(LINT) && !defined(CODECENTER)

-static char rcsid[] = "$Id: base64.c,v 1.1.1.1 2003/11/19 01:51:25 kyu3 Exp $";

-#endif /* not lint */

-

 #include <sys/types.h>

 #include <sys/param.h>

 #include <sys/socket.h>

@@ -101,7 +98,7 @@ static char rcsid[] = "$Id: base64.c,v 1.1.1.1 2003/11/19 01:51:25 kyu3 Exp $";
 #define Assert(Cond) if (!(Cond)) abort()

 

 static const char Base64[] =

-	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

 static const char Pad64 = '=';

 

 /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)

@@ -152,79 +149,79 @@ static const char Pad64 = '=';
    end of the data is performed using the '=' character.

 

    Since all base64 input is an integral number of octets, only the

-         -------------------------------------------------                       

+         -------------------------------------------------

    following cases can arise:

-   

+

        (1) the final quantum of encoding input is an integral

            multiple of 24 bits; here, the final unit of encoded

-	   output will be an integral multiple of 4 characters

-	   with no "=" padding,

+     output will be an integral multiple of 4 characters

+     with no "=" padding,

        (2) the final quantum of encoding input is exactly 8 bits;

            here, the final unit of encoded output will be two

-	   characters followed by two "=" padding characters, or

+     characters followed by two "=" padding characters, or

        (3) the final quantum of encoding input is exactly 16 bits;

            here, the final unit of encoded output will be three

-	   characters followed by one "=" padding character.

+     characters followed by one "=" padding character.

    */

 

 int

 b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize) {

-	size_t datalength = 0;

-	u_char input[3];

-	u_char output[4];

-	size_t i;

-

-	while (2 < srclength) {

-		input[0] = *src++;

-		input[1] = *src++;

-		input[2] = *src++;

-		srclength -= 3;

-

-		output[0] = input[0] >> 2;

-		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);

-		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);

-		output[3] = input[2] & 0x3f;

-		Assert(output[0] < 64);

-		Assert(output[1] < 64);

-		Assert(output[2] < 64);

-		Assert(output[3] < 64);

-

-		if (datalength + 4 > targsize)

-			return (-1);

-		target[datalength++] = Base64[output[0]];

-		target[datalength++] = Base64[output[1]];

-		target[datalength++] = Base64[output[2]];

-		target[datalength++] = Base64[output[3]];

-	}

-    

-	/* Now we worry about padding. */

-	if (0 != srclength) {

-		/* Get what's left. */

-		input[0] = input[1] = input[2] = '\0';

-		for (i = 0; i < srclength; i++)

-			input[i] = *src++;

-	

-		output[0] = input[0] >> 2;

-		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);

-		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);

-		Assert(output[0] < 64);

-		Assert(output[1] < 64);

-		Assert(output[2] < 64);

-

-		if (datalength + 4 > targsize)

-			return (-1);

-		target[datalength++] = Base64[output[0]];

-		target[datalength++] = Base64[output[1]];

-		if (srclength == 1)

-			target[datalength++] = Pad64;

-		else

-			target[datalength++] = Base64[output[2]];

-		target[datalength++] = Pad64;

-	}

-	if (datalength >= targsize)

-		return (-1);

-	target[datalength] = '\0';	/* Returned value doesn't count \0. */

-	return ((int)datalength);

+  size_t datalength = 0;

+  u_char input[3];

+  u_char output[4];

+  size_t i;

+

+  while (2 < srclength) {

+    input[0] = *src++;

+    input[1] = *src++;

+    input[2] = *src++;

+    srclength -= 3;

+

+    output[0] = input[0] >> 2;

+    output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);

+    output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);

+    output[3] = input[2] & 0x3f;

+    Assert(output[0] < 64);

+    Assert(output[1] < 64);

+    Assert(output[2] < 64);

+    Assert(output[3] < 64);

+

+    if (datalength + 4 > targsize)

+      return (-1);

+    target[datalength++] = Base64[output[0]];

+    target[datalength++] = Base64[output[1]];

+    target[datalength++] = Base64[output[2]];

+    target[datalength++] = Base64[output[3]];

+  }

+

+  /* Now we worry about padding. */

+  if (0 != srclength) {

+    /* Get what's left. */

+    input[0] = input[1] = input[2] = '\0';

+    for (i = 0; i < srclength; i++)

+      input[i] = *src++;

+

+    output[0] = input[0] >> 2;

+    output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);

+    output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);

+    Assert(output[0] < 64);

+    Assert(output[1] < 64);

+    Assert(output[2] < 64);

+

+    if (datalength + 4 > targsize)

+      return (-1);

+    target[datalength++] = Base64[output[0]];

+    target[datalength++] = Base64[output[1]];

+    if (srclength == 1)

+      target[datalength++] = Pad64;

+    else

+      target[datalength++] = Base64[output[2]];

+    target[datalength++] = Pad64;

+  }

+  if (datalength >= targsize)

+    return (-1);

+  target[datalength] = '\0';  /* Returned value doesn't count \0. */

+  return ((int)datalength);

 }

 

 /* skips all whitespace anywhere.

@@ -235,123 +232,123 @@ b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize) {
 

 int

 b64_pton(

-	char const *src,

-	u_char *target,

-	size_t targsize

-	)

+  char const *src,

+  u_char *target,

+  size_t targsize

+  )

 {

-	int tarindex, state, ch;

-	char *pos;

-

-	state = 0;

-	tarindex = 0;

-

-	while ((ch = *src++) != '\0') {

-		if (isspace(ch))	/* Skip whitespace anywhere. */

-			continue;

-

-		if (ch == Pad64)

-			break;

-

-		pos = strchr(Base64, ch);

-		if (pos == 0) 		/* A non-base64 character. */

-			return (-1);

-

-		switch (state) {

-		case 0:

-			if (target) {

-				if ((size_t)tarindex >= targsize)

-					return (-1);

-				target[tarindex] = (u_char)((pos - Base64) << 2);

-			}

-			state = 1;

-			break;

-		case 1:

-			if (target) {

-				if ((size_t)tarindex + 1 >= targsize)

-					return (-1);

-				target[tarindex]   |= (u_char)((pos - Base64) >> 4);

-				target[tarindex+1]  = (u_char)(((pos - Base64) & 0x0f)

-							<< 4) ;

-			}

-			tarindex++;

-			state = 2;

-			break;

-		case 2:

-			if (target) {

-				if ((size_t)tarindex + 1 >= targsize)

-					return (-1);

-				target[tarindex]   |= (u_char)((pos - Base64) >> 2);

-				target[tarindex+1]  = (u_char)(((pos - Base64) & 0x03)

-							<< 6);

-			}

-			tarindex++;

-			state = 3;

-			break;

-		case 3:

-			if (target) {

-				if ((size_t)tarindex >= targsize)

-					return (-1);

-				target[tarindex] |= (u_char)(pos - Base64);

-			}

-			tarindex++;

-			state = 0;

-			break;

-		default:

-			abort();

-		}

-	}

-

-	/*

-	 * We are done decoding Base-64 chars.  Let's see if we ended

-	 * on a byte boundary, and/or with erroneous trailing characters.

-	 */

-

-	if (ch == Pad64) {		/* We got a pad char. */

-		ch = *src++;		/* Skip it, get next. */

-		switch (state) {

-		case 0:		/* Invalid = in first position */

-		case 1:		/* Invalid = in second position */

-			return (-1);

-

-		case 2:		/* Valid, means one byte of info */

-			/* Skip any number of spaces. */

-			for ((void)NULL; ch != '\0'; ch = *src++)

-				if (!isspace(ch))

-					break;

-			/* Make sure there is another trailing = sign. */

-			if (ch != Pad64)

-				return (-1);

-			ch = *src++;		/* Skip the = */

-			/* Fall through to "single trailing =" case. */

-			/* FALLTHROUGH */

-

-		case 3:		/* Valid, means two bytes of info */

-			/*

-			 * We know this char is an =.  Is there anything but

-			 * whitespace after it?

-			 */

-			for ((void)NULL; ch != '\0'; ch = *src++)

-				if (!isspace(ch))

-					return (-1);

-

-			/*

-			 * Now make sure for cases 2 and 3 that the "extra"

-			 * bits that slopped past the last full byte were

-			 * zeros.  If we don't check them, they become a

-			 * subliminal channel.

-			 */

-			if (target && target[tarindex] != 0)

-				return (-1);

-		}

-	} else {

-		/*

-		 * We ended by seeing the end of the string.  Make sure we

-		 * have no partial bytes lying around.

-		 */

-		if (state != 0)

-			return (-1);

-	}

-

-	return (tarindex);

+  int tarindex, state, ch;

+  char *pos;

+

+  state = 0;

+  tarindex = 0;

+

+  while ((ch = *src++) != '\0') {

+    if (isspace(ch))  /* Skip whitespace anywhere. */

+      continue;

+

+    if (ch == Pad64)

+      break;

+

+    pos = strchr(Base64, ch);

+    if (pos == 0)     /* A non-base64 character. */

+      return (-1);

+

+    switch (state) {

+    case 0:

+      if (target) {

+        if ((size_t)tarindex >= targsize)

+          return (-1);

+        target[tarindex] = (u_char)((pos - Base64) << 2);

+      }

+      state = 1;

+      break;

+    case 1:

+      if (target) {

+        if ((size_t)tarindex + 1 >= targsize)

+          return (-1);

+        target[tarindex]   |= (u_char)((pos - Base64) >> 4);

+        target[tarindex+1]  = (u_char)(((pos - Base64) & 0x0f)

+              << 4) ;

+      }

+      tarindex++;

+      state = 2;

+      break;

+    case 2:

+      if (target) {

+        if ((size_t)tarindex + 1 >= targsize)

+          return (-1);

+        target[tarindex]   |= (u_char)((pos - Base64) >> 2);

+        target[tarindex+1]  = (u_char)(((pos - Base64) & 0x03)

+              << 6);

+      }

+      tarindex++;

+      state = 3;

+      break;

+    case 3:

+      if (target) {

+        if ((size_t)tarindex >= targsize)

+          return (-1);

+        target[tarindex] |= (u_char)(pos - Base64);

+      }

+      tarindex++;

+      state = 0;

+      break;

+    default:

+      abort();

+    }

+  }

+

+  /*

+   * We are done decoding Base-64 chars.  Let's see if we ended

+   * on a byte boundary, and/or with erroneous trailing characters.

+   */

+

+  if (ch == Pad64) {    /* We got a pad char. */

+    ch = *src++;    /* Skip it, get next. */

+    switch (state) {

+    case 0:   /* Invalid = in first position */

+    case 1:   /* Invalid = in second position */

+      return (-1);

+

+    case 2:   /* Valid, means one byte of info */

+      /* Skip any number of spaces. */

+      for ((void)NULL; ch != '\0'; ch = *src++)

+        if (!isspace(ch))

+          break;

+      /* Make sure there is another trailing = sign. */

+      if (ch != Pad64)

+        return (-1);

+      ch = *src++;    /* Skip the = */

+      /* Fall through to "single trailing =" case. */

+      /* FALLTHROUGH */

+

+    case 3:   /* Valid, means two bytes of info */

+      /*

+       * We know this char is an =.  Is there anything but

+       * whitespace after it?

+       */

+      for ((void)NULL; ch != '\0'; ch = *src++)

+        if (!isspace(ch))

+          return (-1);

+

+      /*

+       * Now make sure for cases 2 and 3 that the "extra"

+       * bits that slopped past the last full byte were

+       * zeros.  If we don't check them, they become a

+       * subliminal channel.

+       */

+      if (target && target[tarindex] != 0)

+        return (-1);

+    }

+  } else {

+    /*

+     * We ended by seeing the end of the string.  Make sure we

+     * have no partial bytes lying around.

+     */

+    if (state != 0)

+      return (-1);

+  }

+

+  return (tarindex);

 }

diff --git a/StdLib/BsdSocketLib/herror.c b/StdLib/BsdSocketLib/herror.c
index e1c9b41f87..c918f3acef 100644
--- a/StdLib/BsdSocketLib/herror.c
+++ b/StdLib/BsdSocketLib/herror.c
@@ -1,32 +1,32 @@
 /*

  * Copyright (c) 1987, 1993

- *	The Regents of the University of California.  All rights reserved.

+ *  The Regents of the University of California.  All rights reserved.

  *

  * Portions copyright (c) 1999, 2000

  * Intel Corporation.

  * All rights reserved.

- * 

+ *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions

  * are met:

- * 

+ *

  * 1. Redistributions of source code must retain the above copyright

  *    notice, this list of conditions and the following disclaimer.

- * 

+ *

  * 2. Redistributions in binary form must reproduce the above copyright

  *    notice, this list of conditions and the following disclaimer in the

  *    documentation and/or other materials provided with the distribution.

- * 

+ *

  * 3. All advertising materials mentioning features or use of this software

  *    must display the following acknowledgement:

- * 

+ *

  *    This product includes software developed by the University of

  *    California, Berkeley, Intel Corporation, and its contributors.

- * 

+ *

  * 4. Neither the name of University, Intel Corporation, or their respective

  *    contributors may be used to endorse or promote products derived from

  *    this software without specific prior written permission.

- * 

+ *

  * THIS SOFTWARE IS PROVIDED BY THE REGENTS, INTEL CORPORATION AND

  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,

  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

@@ -56,12 +56,10 @@
  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS

  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

  * SOFTWARE.

- */

 

-#if defined(LIBC_SCCS) && !defined(lint)

-static char sccsid[] = "@(#)herror.c	8.1 (Berkeley) 6/4/93";

-static char rcsid[] = "$Id: herror.c,v 1.1.1.1 2003/11/19 01:51:28 kyu3 Exp $";

-#endif /* LIBC_SCCS and not lint */

+  herror.c  8.1 (Berkeley) 6/4/93

+  herror.c,v 1.1.1.1 2003/11/19 01:51:28 kyu3 Exp

+ */

 

 #include <sys/types.h>

 #include <sys/uio.h>

@@ -71,15 +69,15 @@ static char rcsid[] = "$Id: herror.c,v 1.1.1.1 2003/11/19 01:51:28 kyu3 Exp $";
 #include <unistd.h>

 

 const char *h_errlist[] = {

-	"Resolver Error 0 (no error)",

-	"Unknown host",				/* 1 HOST_NOT_FOUND */

-	"Host name lookup failure",		/* 2 TRY_AGAIN */

-	"Unknown server error",			/* 3 NO_RECOVERY */

-	"No address associated with name",	/* 4 NO_ADDRESS */

+  "Resolver Error 0 (no error)",

+  "Unknown host",       /* 1 HOST_NOT_FOUND */

+  "Host name lookup failure",   /* 2 TRY_AGAIN */

+  "Unknown server error",     /* 3 NO_RECOVERY */

+  "No address associated with name",  /* 4 NO_ADDRESS */

 };

-int	h_nerr = { sizeof h_errlist / sizeof h_errlist[0] };

+int h_nerr = { sizeof h_errlist / sizeof h_errlist[0] };

 

-int	h_errno;

+int h_errno;

 

 const char *

 hstrerror(

@@ -88,47 +86,47 @@ hstrerror(
 

 /*

  * herror --

- *	print the error indicated by the h_errno value.

+ *  print the error indicated by the h_errno value.

  */

 void

 herror(

-	const char *s

-	)

+  const char *s

+  )

 {

-	struct iovec iov[4];

-	register struct iovec *v = iov;

-	int		i;

+  struct iovec iov[4];

+  register struct iovec *v = iov;

+  int   i;

 

-	if (s && *s) {

-		v->iov_base = (char *)s;

-		v->iov_len = strlen(s);

-		v++;

-		v->iov_base = ": ";

-		v->iov_len = 2;

-		v++;

-	}

-	v->iov_base = (char *)hstrerror(h_errno);

-	v->iov_len = strlen(v->iov_base);

-	v++;

-	v->iov_base = "\n";

-	v->iov_len = 1;

+  if (s && *s) {

+    v->iov_base = (char *)s;

+    v->iov_len = strlen(s);

+    v++;

+    v->iov_base = ": ";

+    v->iov_len = 2;

+    v++;

+  }

+  v->iov_base = (char *)hstrerror(h_errno);

+  v->iov_len = strlen(v->iov_base);

+  v++;

+  v->iov_base = "\n";

+  v->iov_len = 1;

 #ifdef _ORG_FREEBSD_

-	writev(STDERR_FILENO, iov, (v - iov) + 1);

+  writev(STDERR_FILENO, iov, (v - iov) + 1);

 #else

-	for (i = 0; i < (v - iov) + 1; i++)

-		fprintf( stderr, iov[i].iov_base);

+  for (i = 0; i < (v - iov) + 1; i++)

+    fprintf( stderr, iov[i].iov_base);

 #endif

 

 }

 

 const char *

 hstrerror(

-	int err

-	)

+  int err

+  )

 {

-	if (err < 0)

-		return ("Resolver internal error");

-	else if (err < h_nerr)

-		return (h_errlist[err]);

-	return ("Unknown resolver error");

+  if (err < 0)

+    return ("Resolver internal error");

+  else if (err < h_nerr)

+    return (h_errlist[err]);

+  return ("Unknown resolver error");

 }