1/////////////////////////////////////////////////////////////////////////////// 2// 3/// \file main.c 4/// \brief main() 5// 6// Author: Lasse Collin 7// 8// This file has been put into the public domain. 9// You can do whatever you want with this file. 10// 11/////////////////////////////////////////////////////////////////////////////// 12 13#include "private.h" 14#include <ctype.h> 15 16/// Exit status to use. This can be changed with set_exit_status(). 17static enum exit_status_type exit_status = E_SUCCESS; 18 19#if defined(_WIN32) && !defined(__CYGWIN__) 20/// exit_status has to be protected with a critical section due to 21/// how "signal handling" is done on Windows. See signals.c for details. 22static CRITICAL_SECTION exit_status_cs; 23#endif 24 25/// True if --no-warn is specified. When this is true, we don't set 26/// the exit status to E_WARNING when something worth a warning happens. 27static bool no_warn = false; 28 29 30extern void 31set_exit_status(enum exit_status_type new_status) 32{ 33 assert(new_status == E_WARNING || new_status == E_ERROR); 34 35#if defined(_WIN32) && !defined(__CYGWIN__) 36 EnterCriticalSection(&exit_status_cs); 37#endif 38 39 if (exit_status != E_ERROR) 40 exit_status = new_status; 41 42#if defined(_WIN32) && !defined(__CYGWIN__) 43 LeaveCriticalSection(&exit_status_cs); 44#endif 45 46 return; 47} 48 49 50extern void 51set_exit_no_warn(void) 52{ 53 no_warn = true; 54 return; 55} 56 57 58static const char * 59read_name(const args_info *args) 60{ 61 // FIXME: Maybe we should have some kind of memory usage limit here 62 // like the tool has for the actual compression and decompression. 63 // Giving some huge text file with --files0 makes us to read the 64 // whole file in RAM. 65 static char *name = NULL; 66 static size_t size = 256; 67 68 // Allocate the initial buffer. This is never freed, since after it 69 // is no longer needed, the program exits very soon. It is safe to 70 // use xmalloc() and xrealloc() in this function, because while 71 // executing this function, no files are open for writing, and thus 72 // there's no need to cleanup anything before exiting. 73 if (name == NULL) 74 name = xmalloc(size); 75 76 // Write position in name 77 size_t pos = 0; 78 79 // Read one character at a time into name. 80 while (!user_abort) { 81 const int c = fgetc(args->files_file); 82 83 if (ferror(args->files_file)) { 84 // Take care of EINTR since we have established 85 // the signal handlers already. 86 if (errno == EINTR) 87 continue; 88 89 message_error(_("%s: Error reading filenames: %s"), 90 args->files_name, strerror(errno)); 91 return NULL; 92 } 93 94 if (feof(args->files_file)) { 95 if (pos != 0) 96 message_error(_("%s: Unexpected end of input " 97 "when reading filenames"), 98 args->files_name); 99 100 return NULL; 101 } 102 103 if (c == args->files_delim) { 104 // We allow consecutive newline (--files) or '\0' 105 // characters (--files0), and ignore such empty 106 // filenames. 107 if (pos == 0) 108 continue; 109 110 // A non-empty name was read. Terminate it with '\0' 111 // and return it. 112 name[pos] = '\0'; 113 return name; 114 } 115 116 if (c == '\0') { 117 // A null character was found when using --files, 118 // which expects plain text input separated with 119 // newlines. 120 message_error(_("%s: Null character found when " 121 "reading filenames; maybe you meant " 122 "to use `--files0' instead " 123 "of `--files'?"), args->files_name); 124 return NULL; 125 } 126 127 name[pos++] = c; 128 129 // Allocate more memory if needed. There must always be space 130 // at least for one character to allow terminating the string 131 // with '\0'. 132 if (pos == size) { 133 size *= 2; 134 name = xrealloc(name, size); 135 } 136 } 137 138 return NULL; 139} 140 141 142int 143main(int argc, char **argv) 144{ 145#if defined(_WIN32) && !defined(__CYGWIN__) 146 InitializeCriticalSection(&exit_status_cs); 147#endif 148 149 // Set up the progname variable. 150 tuklib_progname_init(argv); 151 152 // Initialize the file I/O. This makes sure that 153 // stdin, stdout, and stderr are something valid. 154 io_init(); 155 156 // Set up the locale and message translations. 157 tuklib_gettext_init(PACKAGE, LOCALEDIR); 158 159 // Initialize handling of error/warning/other messages. 160 message_init(); 161 162 // Set hardware-dependent default values. These can be overriden 163 // on the command line, thus this must be done before args_parse(). 164 hardware_init(); 165 166 // Parse the command line arguments and get an array of filenames. 167 // This doesn't return if something is wrong with the command line 168 // arguments. If there are no arguments, one filename ("-") is still 169 // returned to indicate stdin. 170 args_info args; 171 args_parse(&args, argc, argv); 172 173 if (opt_mode != MODE_LIST && opt_robot) 174 message_fatal(_("Compression and decompression with --robot " 175 "are not supported yet.")); 176 177 // Tell the message handling code how many input files there are if 178 // we know it. This way the progress indicator can show it. 179 if (args.files_name != NULL) 180 message_set_files(0); 181 else 182 message_set_files(args.arg_count); 183 184 // Refuse to write compressed data to standard output if it is 185 // a terminal. 186 if (opt_mode == MODE_COMPRESS) { 187 if (opt_stdout || (args.arg_count == 1 188 && strcmp(args.arg_names[0], "-") == 0)) { 189 if (is_tty_stdout()) { 190 message_try_help(); 191 tuklib_exit(E_ERROR, E_ERROR, false); 192 } 193 } 194 } 195 196 // Set up the signal handlers. We don't need these before we 197 // start the actual action and not in --list mode, so this is 198 // done after parsing the command line arguments. 199 // 200 // It's good to keep signal handlers in normal compression and 201 // decompression modes even when only writing to stdout, because 202 // we might need to restore O_APPEND flag on stdout before exiting. 203 // In --test mode, signal handlers aren't really needed, but let's 204 // keep them there for consistency with normal decompression. 205 if (opt_mode != MODE_LIST) 206 signals_init(); 207 208 // coder_run() handles compression, decompression, and testing. 209 // list_file() is for --list. 210 void (*run)(const char *filename) = opt_mode == MODE_LIST 211 ? &list_file : &coder_run; 212 213 // Process the files given on the command line. Note that if no names 214 // were given, args_parse() gave us a fake "-" filename. 215 for (size_t i = 0; i < args.arg_count && !user_abort; ++i) { 216 if (strcmp("-", args.arg_names[i]) == 0) { 217 // Processing from stdin to stdout. Check that we 218 // aren't writing compressed data to a terminal or 219 // reading it from a terminal. 220 if (opt_mode == MODE_COMPRESS) { 221 if (is_tty_stdout()) 222 continue; 223 } else if (is_tty_stdin()) { 224 continue; 225 } 226 227 // It doesn't make sense to compress data from stdin 228 // if we are supposed to read filenames from stdin 229 // too (enabled with --files or --files0). 230 if (args.files_name == stdin_filename) { 231 message_error(_("Cannot read data from " 232 "standard input when " 233 "reading filenames " 234 "from standard input")); 235 continue; 236 } 237 238 // Replace the "-" with a special pointer, which is 239 // recognized by coder_run() and other things. 240 // This way error messages get a proper filename 241 // string and the code still knows that it is 242 // handling the special case of stdin. 243 args.arg_names[i] = (char *)stdin_filename; 244 } 245 246 // Do the actual compression or decompression. 247 run(args.arg_names[i]); 248 } 249 250 // If --files or --files0 was used, process the filenames from the 251 // given file or stdin. Note that here we don't consider "-" to 252 // indicate stdin like we do with the command line arguments. 253 if (args.files_name != NULL) { 254 // read_name() checks for user_abort so we don't need to 255 // check it as loop termination condition. 256 while (true) { 257 const char *name = read_name(&args); 258 if (name == NULL) 259 break; 260 261 // read_name() doesn't return empty names. 262 assert(name[0] != '\0'); 263 run(name); 264 } 265 266 if (args.files_name != stdin_filename) 267 (void)fclose(args.files_file); 268 } 269 270 // All files have now been handled. If in --list mode, display 271 // the totals before exiting. We don't have signal handlers 272 // enabled in --list mode, so we don't need to check user_abort. 273 if (opt_mode == MODE_LIST) { 274 assert(!user_abort); 275 list_totals(); 276 } 277 278 // If we have got a signal, raise it to kill the program instead 279 // of calling tuklib_exit(). 280 signals_exit(); 281 282 // Make a local copy of exit_status to keep the Windows code 283 // thread safe. At this point it is fine if we miss the user 284 // pressing C-c and don't set the exit_status to E_ERROR on 285 // Windows. 286#if defined(_WIN32) && !defined(__CYGWIN__) 287 EnterCriticalSection(&exit_status_cs); 288#endif 289 290 enum exit_status_type es = exit_status; 291 292#if defined(_WIN32) && !defined(__CYGWIN__) 293 LeaveCriticalSection(&exit_status_cs); 294#endif 295 296 // Suppress the exit status indicating a warning if --no-warn 297 // was specified. 298 if (es == E_WARNING && no_warn) 299 es = E_SUCCESS; 300 301 tuklib_exit(es, E_ERROR, message_verbosity_get() != V_SILENT); 302} 303