如何在 C 中使用 ctime() 从套接字读取字节

Question

目前，我正在做一些练习，试图通过TCP连接模拟时间协议RFC 868。我已经用Java做了服务器，我用C做了客户端。以下是服务器的主要代码行。

private static final long SECONDS_FROM_1900_TO_1970 = 2208988800L; //Long I need in order to calculate the
//time past since 1900. It is because time protocol sets the epoch at 1900 and the java Date class at 
//1970.
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try{
            int serverPort = 37000;
            ServerSocket receivingConnections = new ServerSocket (serverPort);
            for(;;) { //Infinity loop equivalent to while(true)
              clientConnection = receivingConnections.accept();
              System.out.println("Connection established with client IP: " +clientConnection.getInetAddress());
                try{
                    in = new DataInputStream(clientConnection.getInputStream());
                    out = new DataOutputStream(clientConnection.getOutputStream());
                    Date actualTime = new Date();//Date gives us the second for the epoch until 1970. Had to import utils.date
                    long secondsSince1970 = (actualTime.getTime())/1000;//I divide the time by 1000 because actualTime.getTime()
                    //returns me the result in ms
                    long secondsFromTheBeginning = secondsSince1970 + SECONDS_FROM_1900_TO_1970; //Total seconds i do need to calculate
                    //the time from 1990 in order to respect RFC 868 specification
                    byte[] actualTimeToBytes = new byte[4]; //Byte structure I need to send to the client. 4 bytes = 32 bits.
                    //With the next 4 lines of code I will introduce the whole long into 4 bytes. A long takes 4 bytes = 32 bits.
                    actualTimeToBytes[0] = (byte) ((secondsFromTheBeginning & 0x00000000FF000000L) >> 24);
                    actualTimeToBytes[1] = (byte) ((secondsFromTheBeginning & 0x0000000000FF0000L) >> 16);
                    actualTimeToBytes[2] = (byte) ((secondsFromTheBeginning & 0x000000000000FF00L) >> 8);
                    actualTimeToBytes[3] = (byte) (secondsFromTheBeginning & 0x00000000000000FFL);
                    String s = new String(actualTimeToBytes);
                    System.out.println(secondsFromTheBeginning); //The actual time being sent over the socket..
                    System.out.println(s); // The actual byte being sent over the socket.
                    out.write(actualTimeToBytes);//Here I send to the receiver the time in Byte form via the socket
                    out.flush();
                    System.out.println("The time was indeed sent to: " +clientConnection.getInetAddress());

                } catch (IOException e){System.out.println("Error: "+e.getMessage()); }
                finally { if (clientConnection != null) {
                    System.out.println("Connection finished with client IP: " +clientConnection.getInetAddress());
                    clientConnection.close(); 
                }
            }
        } 
    } catch (IOException ex) {
        System.err.println(ex);
    }
    }

服务器工作正常，但在执行客户端时出现问题。客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <time.h>

/*****************************************************
 * Reproduced from Unix Network Programming
                W.Richard Stevens
                Prentice Hall Software Series 1990
 * Definitions for TCP and UDP client/server programs
 */
#include    <sys/types.h>
#include    <sys/socket.h>
#include    <netinet/in.h>
#include    <arpa/inet.h>
/*****************************************************/

#define SERVERPORT 37000
#define SERVERIP "192.168.0.18"
#define TIMELENGTHBYTES 4
/* 
 * Program a new function that reads four bytes from the socket:
 * int readDate(...)
 */
int readDate(int *sockfd){
     int    n;
     char   buffer[4];
     unsigned long  lorovrigida;
    n = read(*sockfd, buffer, 4);  
   lorovrigida = (buffer[0]<<24) + (buffer[1]<<16) + (buffer[2]<<8) + (buffer[3]);
   lorovrigida-=2208988800;
    printf(ctime(&lorovrigida));
    if ( n < 0 ) {
    printf("TIMECLNT: Error in read()n");
    exit(EXIT_FAILURE);
    }
}
int connectToServer(char *ip, int port, int *sockfd) {
    int rv = 0;    
    struct sockaddr_in serv_addr;
    char buf[4];
    bzero((char *) &serv_addr, sizeof (serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(SERVERIP);
    serv_addr.sin_port = htons(SERVERPORT);
    if ((*sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        rv = -1;
    } else {
        if (connect(*sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) {
            rv = -2;
        }
    }
    return rv;
}
int main(int argc, char** argv) {
    int e, sockfd;

    if ((e = connectToServer(SERVERIP, SERVERPORT, &sockfd)) != 0) {
        printf("Error on call to connectToServer: %dn", e);
        exit(e);
    }
    printf("Successfully connected to servern");
    if(sockfd==NULL)
        printf("El socket esta vacion");
    fflush(stdout);    
    /*
     * Call the readDate() function and print out the result:
     */
    readDate(&sockfd);

    return (EXIT_SUCCESS);
}

主要问题是我真的不知道如何读取收到的 4 个字节。当我打印出lorovrigida时，它似乎是一个巨大的随机数字。

我怎样才能做正确的阅读？是因为我使用的是无符号长整型吗？我只是被困住了，因为我尝试了很多不同的方法，但没有任何效果。

谢谢你的帮助。

Answer 1

我不认为这是字节序问题的问题，因为您的java server已经处理过了。

在你的客户端char buffer[4];中，你将其声明为signed，当进行位移位时，当某个字节的最高位为 1 时，你不会得到正确的结果。定义为unsigned char buffer[4];

 unsigned char ua = 0x80;
 unsigned int b = ua << 1;
 printf("%un", b);
 char a = 0x80;
 unsigned int c = a << 1;
 printf("%un", c);

结果：

256
4294967040

Answer 2

32 位结果的重建是一个问题，从 4 个可能已签名的char开始。

假设char是有符号的，2的补码...

添加buffer[3]时，它首先经历通常的整数提升。 这意味着像 1000_0000 （-128） 这样的位模式变得1111_1111_...1000_0000 . 前导 1 位的数量取决于int位宽度。

---

若要避免所有这些符号扩展，最好使用无符号类型。

国际海事组织：推荐#4

// Method 1 - cast buffer
int readDate(int *sockfd) {
  char   buffer[4];
  int    n;
  unsigned long  lorovrigida;
  n = read(*sockfd, buffer, 4);  
  if ( n < 0 ) {
    printf("TIMECLNT: Error in read()n");
    exit(EXIT_FAILURE);
  }
  lorovrigida = ((unsigned char)buffer[0]<<24) + ((unsigned char)buffer[1]<<16) + 
      ((unsigned char)buffer[2]<<8) + ((unsigned char)buffer[3]);
  ....
}
// Method 2 - use unsigned char type
int readDate_2(int *sockfd) {
  unsigned char buffer[4];
  ...
  lorovrigida = (buffer[0]<<24) + (buffer[1]<<16) + 
      (buffer[2]<<8) + (buffer[3]);
  ....
}
// Method 3 - exact size types
int readDate_2(int *sockfd) {
  uint8_t buffer[4];
  ...
  lorovrigida = (buffer[0]<<24) + (buffer[1]<<16) + 
      (buffer[2]<<8) + (buffer[3]);
  ....
}
// Method 4 - * by unsigned
int readDate_2(int *sockfd) {
  uint8_t buffer[4];
  ...
  lorovrigida = buffer[0]*0x1000000LU + buffer[1]*0x10000LU + 
      buffer[2]*0x100u + buffer[3];
  ....
}
// Method 5 - successive or-ing
int readDate_2(int *sockfd) {
  uint8_t buffer[4];
  ...
  lorovrigida = buffer[0];
  lorovrigida = lorovrigida << 8 | buffer[1];
  lorovrigida = lorovrigida << 8 | buffer[2];
  lorovrigida = lorovrigida << 8 | buffer[3];
  ....
}

方法 1 - 3 在系统使用 16 位无符号时会受到可移植性的影响。

优化编译器可以为这些方法生成类似的代码。

此外：代码可能会受益于在我的编译器中额外使用固定宽度（如 uint32_t）而不是unsigned long（64 位）。