← Back to branch summary

~dave-terei/libmemcached/sasl-fixes

« back to all changes in this revision

Viewing changes to clients/memcat.cc

Update libtest/associated tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
clients/memcat.cc
45
45
  memcached_return_t rc;
46
46
  memcached_server_st *servers;
47
47
 
48
 
  int return_code= 0;
 
48
  int return_code= EXIT_SUCCESS;
49
49
 
50
50
  options_parse(argc, argv);
51
51
  initialize_sockets();
55
55
    char *temp;
56
56
 
57
57
    if ((temp= getenv("MEMCACHED_SERVERS")))
 
58
    {
58
59
      opt_servers= strdup(temp);
 
60
    }
59
61
    else
60
62
    {
61
 
      fprintf(stderr, "No Servers provided\n");
62
 
      exit(1);
 
63
      std::cerr << "No servers provied" << std::endl;
 
64
      exit(EXIT_FAILURE);
63
65
    }
64
66
  }
65
67
 
100
102
      if (opt_displayflag)
101
103
      {
102
104
        if (opt_verbose)
103
 
          printf("key: %s\nflags: ", argv[optind]);
104
 
        printf("%x\n", flags);
 
105
        {
 
106
          std::cout << "key: " << argv[optind] << std::endl << "flags: " << flags << std::endl;
 
107
        }
105
108
      }
106
109
      else
107
110
      {
108
111
        if (opt_verbose)
109
112
        {
110
 
          printf("key: %s\nflags: %x\nlength: %lu\nvalue: ",
111
 
                 argv[optind], flags, (unsigned long)string_length);
 
113
          std::cout << "key: " << argv[optind] << std::endl << "flags: " << flags << "length: " << string_length << std::endl << "value: ";
112
114
        }
113
115
 
114
116
        if (opt_file)
115
117
        {
116
 
          FILE *fp;
117
 
          size_t written;
118
 
 
119
 
          fp= fopen(opt_file, "w");
120
 
          if (!fp)
 
118
          FILE *fp= fopen(opt_file, "w");
 
119
          if (fp == NULL)
121
120
          {
122
121
            perror("fopen");
123
 
            return_code= -1;
 
122
            return_code= EXIT_FAILURE;
124
123
            break;
125
124
          }
126
125
 
127
 
          written= fwrite(string, 1, string_length, fp);
 
126
          size_t written= fwrite(string, 1, string_length, fp);
128
127
          if (written != string_length) 
129
128
          {
130
 
            fprintf(stderr, "error writing file (written %lu, should be %lu)\n", (unsigned long)written, (unsigned long)string_length);
131
 
            return_code= -1;
 
129
            std::cerr << "error writing file to file " << opt_file << " wrote " << written << ", should have written" << string_length << std::endl;
 
130
            return_code= EXIT_FAILURE;
132
131
            break;
133
132
          }
134
133
 
135
134
          if (fclose(fp))
136
135
          {
137
 
            fprintf(stderr, "error closing file\n");
138
 
            return_code= -1;
 
136
            std::cerr << "error closing " << opt_file << std::endl;
 
137
            return_code= EXIT_FAILURE;
139
138
            break;
140
139
          }
141
140
        }
142
141
        else
143
142
        {
144
 
            printf("%.*s\n", (int)string_length, string);
 
143
          std::cout.write(string, string_length);
 
144
          std::cout << std::endl;
145
145
        }
146
146
        free(string);
147
147
      }
148
148
    }
149
149
    else if (rc != MEMCACHED_NOTFOUND)
150
150
    {
151
 
      fprintf(stderr, "memcat: %s: memcache error %s",
152
 
              argv[optind], memcached_strerror(memc, rc));
 
151
      std::cerr << "error on " << argv[optind] << "(" <<  memcached_strerror(memc, rc) << ")";
153
152
      if (memcached_last_error_errno(memc))
154
153
      {
155
 
        fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
 
154
        std::cerr << " system error (" << strerror(memcached_last_error_errno(memc)) << ")" << std::endl;
156
155
      }
157
 
      fprintf(stderr, "\n");
 
156
      std::cerr << std::endl;
158
157
 
159
 
      return_code= -1;
 
158
      return_code= EXIT_FAILURE;
160
159
      break;
161
160
    }
162
161
    else // Unknown Issue
163
162
    {
164
 
      fprintf(stderr, "memcat: %s not found\n", argv[optind]);
165
 
      return_code= -1;
 
163
      std::cerr << "error on " << argv[optind] << "("<< memcached_strerror(NULL, rc) << ")" << std::endl;
 
164
      return_code= EXIT_FAILURE;
166
165
    }
167
166
    optind++;
168
167
  }
170
169
  memcached_free(memc);
171
170
 
172
171
  if (opt_servers)
 
172
  {
173
173
    free(opt_servers);
 
174
  }
174
175
  if (opt_hash)
 
176
  {
175
177
    free(opt_hash);
 
178
  }
176
179
 
177
180
  return return_code;
178
181
}