1                 : #include "serialise.hh"
       2                 : #include "util.hh"
       3                 : 
       4                 : #include <cstring>
       5                 : 
       6                 : 
       7                 : namespace nix {
       8                 : 
       9                 : 
      10            8301 : void FdSink::operator () (const unsigned char * data, unsigned int len)
      11                 : {
      12            8301 :     writeFull(fd, data, len);
      13            8301 : }
      14                 : 
      15                 : 
      16            8686 : void FdSource::operator () (unsigned char * data, unsigned int len)
      17                 : {
      18            8686 :     readFull(fd, data, len);
      19            8594 : }
      20                 : 
      21                 : 
      22           43881 : void writePadding(unsigned int len, Sink & sink)
      23                 : {
      24           43881 :     if (len % 8) {
      25                 :         unsigned char zero[8];
      26           32871 :         memset(zero, 0, sizeof(zero));
      27           32871 :         sink(zero, 8 - (len % 8));
      28                 :     }
      29           43881 : }
      30                 : 
      31                 : 
      32           46924 : void writeInt(unsigned int n, Sink & sink)
      33                 : {
      34                 :     unsigned char buf[8];
      35           46924 :     memset(buf, 0, sizeof(buf));
      36           46924 :     buf[0] = n & 0xff;
      37           46924 :     buf[1] = (n >> 8) & 0xff;
      38           46924 :     buf[2] = (n >> 16) & 0xff;
      39           46924 :     buf[3] = (n >> 24) & 0xff;
      40           46924 :     sink(buf, sizeof(buf));
      41           46924 : }
      42                 : 
      43                 : 
      44               6 : void writeLongLong(unsigned long long n, Sink & sink)
      45                 : {
      46                 :     unsigned char buf[8];
      47               6 :     buf[0] = n & 0xff;
      48               6 :     buf[1] = (n >> 8) & 0xff;
      49               6 :     buf[2] = (n >> 16) & 0xff;
      50               6 :     buf[3] = (n >> 24) & 0xff;
      51               6 :     buf[4] = (n >> 32) & 0xff;
      52               6 :     buf[5] = (n >> 40) & 0xff;
      53               6 :     buf[6] = (n >> 48) & 0xff;
      54               6 :     buf[7] = (n >> 56) & 0xff;
      55               6 :     sink(buf, sizeof(buf));
      56               6 : }
      57                 : 
      58                 : 
      59           38224 : void writeString(const string & s, Sink & sink)
      60                 : {
      61           38224 :     unsigned int len = s.length();
      62           38224 :     writeInt(len, sink);
      63           38224 :     sink((const unsigned char *) s.c_str(), len);
      64           38224 :     writePadding(len, sink);
      65           38224 : }
      66                 : 
      67                 : 
      68             139 : void writeStringSet(const StringSet & ss, Sink & sink)
      69                 : {
      70             139 :     writeInt(ss.size(), sink);
      71             347 :     for (StringSet::iterator i = ss.begin(); i != ss.end(); ++i)
      72             208 :         writeString(*i, sink);
      73             139 : }
      74                 : 
      75                 : 
      76            2465 : void readPadding(unsigned int len, Source & source)
      77                 : {
      78            2465 :     if (len % 8) {
      79                 :         unsigned char zero[8];
      80            2187 :         unsigned int n = 8 - (len % 8);
      81            2187 :         source(zero, n);
      82           11265 :         for (unsigned int i = 0; i < n; i++)
      83            9078 :             if (zero[i]) throw Error("non-zero padding");
      84                 :     }
      85            2465 : }
      86                 : 
      87                 : 
      88            5599 : unsigned int readInt(Source & source)
      89                 : {
      90                 :     unsigned char buf[8];
      91            5599 :     source(buf, sizeof(buf));
      92            5507 :     if (buf[4] || buf[5] || buf[6] || buf[7])
      93               0 :         throw Error("implementation cannot deal with > 32-bit integers");
      94                 :     return
      95                 :         buf[0] |
      96                 :         (buf[1] << 8) |
      97                 :         (buf[2] << 16) |
      98            5507 :         (buf[3] << 24);
      99                 : }
     100                 : 
     101                 : 
     102               6 : unsigned long long readLongLong(Source & source)
     103                 : {
     104                 :     unsigned char buf[8];
     105               6 :     source(buf, sizeof(buf));
     106                 :     return
     107                 :         ((unsigned long long) buf[0]) |
     108                 :         ((unsigned long long) buf[1] << 8) |
     109                 :         ((unsigned long long) buf[2] << 16) |
     110                 :         ((unsigned long long) buf[3] << 24) |
     111                 :         ((unsigned long long) buf[4] << 32) |
     112                 :         ((unsigned long long) buf[5] << 40) |
     113                 :         ((unsigned long long) buf[6] << 48) |
     114               6 :         ((unsigned long long) buf[7] << 56);
     115                 : }
     116                 : 
     117                 : 
     118            2332 : string readString(Source & source)
     119                 : {
     120            2332 :     unsigned int len = readInt(source);
     121            2332 :     unsigned char * buf = new unsigned char[len];
     122            2332 :     AutoDeleteArray<unsigned char> d(buf);
     123            2332 :     source(buf, len);
     124            2332 :     readPadding(len, source);
     125            2332 :     return string((char *) buf, len);
     126                 : }
     127                 : 
     128                 :  
     129             139 : StringSet readStringSet(Source & source)
     130                 : {
     131             139 :     unsigned int count = readInt(source);
     132             139 :     StringSet ss;
     133             139 :     while (count--)
     134             208 :         ss.insert(readString(source));
     135               0 :     return ss;
     136                 : }
     137                 : 
     138                 : 
     139                 : }