CAN-binder/libs/nanopb/examples/network_server/client.c

   1 /* This is a simple TCP client that connects to port 1234 and prints a list
   2  * of files in a given directory.
   3  *
   4  * It directly deserializes and serializes messages from network, minimizing
   5  * memory use.
   6  *
   7  * For flexibility, this example is implemented using posix api.
   8  * In a real embedded system you would typically use some other kind of
   9  * a communication and filesystem layer.
  10  */
  11
  12 #include <sys/socket.h>
  13 #include <sys/types.h>
  14 #include <netinet/in.h>
  15 #include <unistd.h>
  16 #include <dirent.h>
  17 #include <stdio.h>
  18 #include <string.h>
  19
  20 #include <pb_encode.h>
  21 #include <pb_decode.h>
  22
  23 #include "fileproto.pb.h"
  24 #include "common.h"
  25
  26 /* This callback function will be called once for each filename received
  27  * from the server. The filenames will be printed out immediately, so that
  28  * no memory has to be allocated for them.
  29  */
  30 bool printfile_callback(pb_istream_t *stream, const pb_field_t *field, void **arg)
  31 {
  32     FileInfo fileinfo = {};
  33
  34     if (!pb_decode(stream, FileInfo_fields, &fileinfo))
  35         return false;
  36
  37     printf("%-10lld %s\n", (long long)fileinfo.inode, fileinfo.name);
  38
  39     return true;
  40 }
  41
  42 /* This function sends a request to socket 'fd' to list the files in
  43  * directory given in 'path'. The results received from server will
  44  * be printed to stdout.
  45  */
  46 bool listdir(int fd, char *path)
  47 {
  48     /* Construct and send the request to server */
  49     {
  50         ListFilesRequest request = {};
  51         pb_ostream_t output = pb_ostream_from_socket(fd);
  52         uint8_t zero = 0;
  53
  54         /* In our protocol, path is optional. If it is not given,
  55          * the server will list the root directory. */
  56         if (path == NULL)
  57         {
  58             request.has_path = false;
  59         }
  60         else
  61         {
  62             request.has_path = true;
  63             if (strlen(path) + 1 > sizeof(request.path))
  64             {
  65                 fprintf(stderr, "Too long path.\n");
  66                 return false;
  67             }
  68
  69             strcpy(request.path, path);
  70         }
  71
  72         /* Encode the request. It is written to the socket immediately
  73          * through our custom stream. */
  74         if (!pb_encode(&output, ListFilesRequest_fields, &request))
  75         {
  76             fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&output));
  77             return false;
  78         }
  79
  80         /* We signal the end of request with a 0 tag. */
  81         pb_write(&output, &zero, 1);
  82     }
  83
  84     /* Read back the response from server */
  85     {
  86         ListFilesResponse response = {};
  87         pb_istream_t input = pb_istream_from_socket(fd);
  88
  89         /* Give a pointer to our callback function, which will handle the
  90          * filenames as they arrive. */
  91         response.file.funcs.decode = &printfile_callback;
  92
  93         if (!pb_decode(&input, ListFilesResponse_fields, &response))
  94         {
  95             fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&input));
  96             return false;
  97         }
  98
  99         /* If the message from server decodes properly, but directory was
 100          * not found on server side, we get path_error == true. */
 101         if (response.path_error)
 102         {
 103             fprintf(stderr, "Server reported error.\n");
 104             return false;
 105         }
 106     }
 107
 108     return true;
 109 }
 110
 111 int main(int argc, char **argv)
 112 {
 113     int sockfd;
 114     struct sockaddr_in servaddr;
 115     char *path = NULL;
 116
 117     if (argc > 1)
 118         path = argv[1];
 119
 120     sockfd = socket(AF_INET, SOCK_STREAM, 0);
 121
 122     /* Connect to server running on localhost:1234 */
 123     memset(&servaddr, 0, sizeof(servaddr));
 124     servaddr.sin_family = AF_INET;
 125     servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 126     servaddr.sin_port = htons(1234);
 127
 128     if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0)
 129     {
 130         perror("connect");
 131         return 1;
 132     }
 133
 134     /* Send the directory listing request */
 135     if (!listdir(sockfd, path))
 136         return 2;
 137
 138     /* Close connection */
 139     close(sockfd);
 140
 141     return 0;
 142 }