int
main(int argc, char **argv)
{
procargs(&argc,&argv);
/* XXX This has grown to the point that it should be cleaned up.
*/
if (debugflag) {
if (ioctl(fd,SCIOCDEBUG,&debuglevel) == -1)
err(errno, "SCIODEBUG");
} else if (commandflag) {
char *fmt;
if (argc < 1) {
fprintf(stderr, "Need the command format string.\n");
usage();
}
fmt = argv[0];
argc -= 1;
argv += 1;
do_cmd(fd, fmt, argc, argv);
} else if (modeflag)
mode_edit(fd, modepage, editflag, argc, argv);
exit(0);
}
int main(int argc, char *argv[])
{
int ret, i;
char *ipatsfile;
float *feats, *targs;
char **class_set;
int *classes;
int nPats, nInps, nOuts;
float *means, *stddevs;
/* Process the command line arguments */
procargs(argc, argv, &ipatsfile);
/* Read in the input feature vector file */
if((ret = read_bin_nnpats(ipatsfile, &feats, &targs, &classes,
&class_set, &nPats, &nInps, &nOuts))){
exit(ret);
}
/* Do not need target vectors and class information to */
/* compute global statistics across feature vector coef, */
/* so deallocate these other resources. */
free(targs);
free(classes);
for(i = 0; i < nOuts; i++)
free(class_set[i]);
free(class_set);
/* Compute the mean and stddev for each feature vector coef */
if((ret = comp_znorm_stats(&means, &stddevs, feats, nPats, nInps))){
free(feats);
exit(ret);
}
/* Report the resulting statistics to stdout */
for(i = 0; i < nInps; i++){
printf("%f\t%e\n", means[i], stddevs[i]);
}
/* Deallocate remaining resources */
free(feats);
free(means);
free(stddevs);
/* Exit successful */
exit(0);
}
/*************************************************************************
**************************************************************************
main - Entry point.
Input:
argc - number of command line arguments
argv - array of string values of command line arguments
**************************************************************************/
int main(int argc, char **argv)
{
int read_status, i;
char *filename;
const CAN_CONFIG *conf = NULL, *next_conf;
CAN_CONTEXT file_stats, conf_stats, total_stats;
ANSI_NIST *ansi_nist;
char *config_files[MAX_CONFIG_FILES];
int config_count;
init_result_accumulator(&total_stats, "Grand Total");
config_files[0] = DEFAULT_CONFIG_FILE;
procargs(argc, argv, config_files, MAX_CONFIG_FILES, &config_count);
for (i = 0; i < config_count; i++) {
init_result_accumulator(&conf_stats, config_files[i]);
next_conf = read_config(&conf_stats, conf);
if (NULL == next_conf) {
return EXIT_FAILURE;
}
aggregate_result_accumulator(&total_stats, &conf_stats);
conf = next_conf;
}
for (i = optind; argv[i] != NULL; i++) {
filename = argv[i];
init_result_accumulator(&file_stats, filename);
read_status = read_ANSI_NIST_file(filename, &ansi_nist);
if(read_status != 0) {
++file_stats.issue[LOGTP_EXEC-LOGTP_BASE][LOGL_ERROR-LOGL_BASE];
} else {
check_ansi_nist(conf, ansi_nist, &file_stats);
free_ANSI_NIST(ansi_nist);
}
aggregate_result_accumulator(&total_stats, &file_stats);
}
if (optind+1 < argc) {
report_result_accumulator(conf, &total_stats, TRUE);
}
return EXIT_SUCCESS;
}
proc_args getProcRawArgs(int pid, size_t argmax) {
proc_args args;
std::vector<char> procargs(argmax);
int mib[3] = {CTL_KERN, KERN_PROCARGS2, pid};
if (sysctl(mib, 3, procargs.data(), &argmax, nullptr, 0) == -1 ||
argmax == 0) {
return args;
}
// The number of arguments is an integer in front of the result buffer.
int nargs = 0;
memcpy(&nargs, procargs.data(), sizeof(nargs));
// Walk the \0-tokenized list of arguments until reaching the returned 'max'
// number of arguments or the number appended to the front.
const char* current_arg = &procargs[0] + sizeof(nargs);
// Then skip the exec/program name.
auto exec_name = std::string(current_arg);
current_arg += exec_name.size() + 1;
while (current_arg < &procargs[argmax]) {
// Skip optional null-character padding.
if (*current_arg == '\0') {
current_arg++;
continue;
}
auto string_arg = std::string(current_arg);
if (string_arg.size() > 0) {
if (nargs > 0) {
// The first nargs are CLI arguments, afterward they are environment.
args.args.push_back(string_arg);
nargs--;
} else {
size_t idx = string_arg.find_first_of("=");
if (idx != std::string::npos && idx > 0) {
args.env[string_arg.substr(0, idx)] = string_arg.substr(idx + 1);
}
}
}
current_arg += string_arg.size() + 1;
}
return args;
}
int main(int argc, char *argv[])
{
char *ifile, *ofile;
ANSI_NIST *ansi_nist;
int ret;
procargs(argc, argv, &ifile, &ofile);
if((ret = read_fmttext_file(ifile, &ansi_nist)))
exit(ret);
if((ret = write_ANSI_NIST_file(ofile, ansi_nist))){
free_ANSI_NIST(ansi_nist);
exit(ret);
}
fprintf(stderr, "ANSI_NIST bytes = %d\n", ansi_nist->num_bytes);
free_ANSI_NIST(ansi_nist);
exit(0);
}
int main(int argc, char *argv[])
{
char *ifile, *ofile;
int ret;
ANSI_NIST *ansi_nist;
/* Process command line arguments. */
procargs(argc, argv, &ifile, &ofile);
/* Read in an ANSI/NIST file into memory. */
if((ret = read_ANSI_NIST_file(ifile, &ansi_nist)))
exit(ret);
/* Convert Type-9 records. */
if((ret = iafis2nist_type_9s(ansi_nist))){
free_ANSI_NIST(ansi_nist);
exit(ret);
}
/* Convert any Type-4&6 records to Type-13&14. */
if((ret = iafis2nist_fingerprints(ansi_nist))){
free_ANSI_NIST(ansi_nist);
exit(ret);
}
/* Write out new ANSI/NIST file. */
if((ret = write_ANSI_NIST_file(ofile, ansi_nist))){
free_ANSI_NIST(ansi_nist);
exit(ret);
}
/* Deallocate working memory. */
free_ANSI_NIST(ansi_nist);
/* Exit normally. */
exit(0);
}
int main(int argc, char *argv[])
{
unsigned char *data, **pdata, *filename;
int ret, i, w, h, d, img_type, dlen;
seg_rec_coords *fing_boxes;
int ppi, lossyflag = 0;
int nf;
procargs(argc, argv);
if (old_style_args_flag) {
/* This code supports the old-style invocation using 7 arguments
and allowing different kinds of image files. */
/* FGP 1-12 is single finger : 13-14 four finger slaps : 15 for
two thumbs : Craig said it would be good to eliminate 23 and
use 15 instead. -- jck */
if(fgp < 1 && fgp > 14 && fgp != 15) {
fprintf(stderr, "ERROR: %s: Invalid FGP (%d). "
"Expecting 1-14 or 15 (Two thumbs)\n", argv[0], fgp);
exit(-2);
}
if(fgp < 15 && fgp > 12)
nf = 4;
else if(fgp == 15)
nf = 2;
else
nf = 1;
/* READ THE INPUT FILE */
if((ret = read_and_decode_grayscale_image(ifile, &img_type, &data, &dlen,
&w, &h, &d, &ppi)))
exit(ret);
/* TRY TO SEGMENT FINGER IMAGE */
if((ret = segment_fingers(data, w, h, &fing_boxes, nf, fgp, bthr_adj,
rot_search)))
exit(ret);
/* PARSE FINGERS FROM ORIGINAL FINGER IMAGE */
if((ret = parse_segfing(&pdata, data, w, h, fing_boxes, nf, rot_seg)))
exit(ret);
free(data);
/* OUTPUT RESULTS TO FILE */
filename = basename(ifile);
if((ret = write_parsefing(filename, -1, fgp, comp, ppi,
lossyflag, pdata, fing_boxes, nf, rot_seg)))
exit(ret);
free(fing_boxes);
for(i = 0; i < nf; i++)
free(pdata[i]);
free(pdata);
/* End of code supporting old-style interface. */
} else { /* ANSI/NIST file */
/* This code, from here to the end, supports the new-style
interface for processing several images within ANSI/NIST files. */
ANSI_NIST *ansi_nist, *new_ansi_nist;
RECORD *imgrecord;
FIELD *impfield, *fgpfield;
char *fgp_str, *endp;
int rec_i, imgrecord_i, img_id, impfield_i, imp, matches = 0;
double ppmm;
int img_fgp, img_bthr_adj; /* per-image values */
char *filename;
if (read_ANSI_NIST_file(ifile, &ansi_nist) < 0)
exit(EXIT_FAILURE);
if (ofile != NULL) {
if (copy_ANSI_NIST(&new_ansi_nist, ansi_nist) < 0)
exit(EXIT_FAILURE);
}
if (NULL == (filename = malloc(strlen(ifile)+1))) {
fprintf(stderr, "ERROR : cannot allocate %d bytes for filename %s\n",
strlen(ifile)+1, ifile);
exit(EXIT_FAILURE);
}
/* this loop's index jumps from one grayprint to the next */
for ( rec_i = 1;
(ret = lookup_ANSI_NIST_grayprint(&imgrecord, &imgrecord_i,
rec_i, ansi_nist)) > 0;
rec_i = imgrecord_i + 1 ) {
/* Skip latent images. */
if (!lookup_IMP_field(&impfield, &impfield_i, imgrecord))
continue;
imp = (int)strtol((char *)impfield->subfields[0]->items[0]->value,
&endp, 10);
if ('\0' != *endp) {
fprintf(stderr, "ERROR : main : corrupt IMP value: %s\n",
(char *)impfield->subfields[0]->items[0]->value);
exit(EXIT_FAILURE);
}
if (imp_is_latent(imp))
continue;
/* Skip records that don't match our command-line criteria. */
if (select_ANSI_NIST_record(imgrecord, opt_rec_sel) <= 0)
continue;
/* If we get this far it's the right kind of image. */
++matches;
/* Figure out the finger position code. */
if (TYPE_4_ID == imgrecord->type) {
img_id = BIN_IMAGE_ID;
fgpfield = imgrecord->fields[FGP_ID-1];
} else if (TYPE_14_ID == imgrecord->type) {
img_id = DAT2_ID;
fgpfield = imgrecord->fields[FGP3_ID-1];
} else {
fprintf(stderr, "WARNING : main : skipped unexpected record type "
"index %d, Type-%u\n", imgrecord_i+1, imgrecord->type);
continue;
}
if (UNSET == fgp) {
if ( fgpfield->subfields[0]->num_items > 1 &&
(TYPE_14_ID == imgrecord->type ||
strtol((char *)fgpfield->subfields[0]->items[1]->value,
&endp, 10) != 255) ) {
if ('\0' != *endp) {
fprintf(stderr, "ERROR : main : corrupt FGP value: %s\n",
(char *)fgpfield->subfields[0]->items[1]->value);
exit(EXIT_FAILURE);
}
fprintf(stderr, "WARNING : main : multiple items in subfield, "
" using only the first, [%d.%u.1] [Type-%u.03%u]\n",
imgrecord_i+1, fgpfield->field_int+1,
imgrecord->type, fgpfield->field_int+1);
}
fgp_str = (char *)fgpfield->subfields[0]->items[0]->value;
img_fgp = strtol(fgp_str, &endp, 10);
if ('\0' != *endp) {
fprintf(stderr, "WARNING : main : currupt FGP value: %s\n",
fgp_str);
exit(EXIT_FAILURE);
}
} else {
img_fgp = fgp;
}
/* Determine expected number of fingers in image. */
if (19 == img_fgp) /* ignore TIP or EJI images */
continue;
else if (img_fgp == 13 || img_fgp == 14)
nf = 4;
else if (15 == img_fgp)
nf = 2;
else
nf = 1;
/* Turn on binary threshold adjustment for non-livescan
prints, assuming they are from inked-paper. */
if (UNSET == bthr_adj) {
img_bthr_adj = !imp_is_live_scan(imp);
} else {
img_bthr_adj = bthr_adj;
}
if (UNSET == comp)
comp = 0; /* default compression */
if (UNSET == rot_search)
rot_search = 0; /* default search rotation */
if (UNSET == rot_seg)
rot_seg = 0; /* default output rotation */
if (verbose)
fprintf(stderr, "record index %d, Type-%u, fgp=%d, nf=%d, "
"imp=%d, bthr_adj=%d, rot_search=%d, comp=%d, rot_seg=%d\n",
imgrecord_i+1, imgrecord->type, img_fgp, nf,
imp, img_bthr_adj, rot_search, comp, rot_seg);
ret = decode_ANSI_NIST_image(&data, &w, &h, &d, &ppmm,
ansi_nist, imgrecord_i, 1);
if (ret < 0)
exit(EXIT_FAILURE);
else if (0 == ret)
continue; /* unsuitable image ignored */
ppi = sround(ppmm * MM_PER_INCH);
if (segment_fingers(data, w, h, &fing_boxes, nf, img_fgp,
img_bthr_adj, rot_search))
exit(EXIT_FAILURE);
if (parse_segfing(&pdata, data, w, h, fing_boxes, nf, rot_seg))
exit(EXIT_FAILURE);
if (ofile != NULL) {
/* Convert Type-4 to 14 if necessary. */
if (TYPE_4_ID == imgrecord->type) {
RECORD *new_imgrecord;
ret = iafis2nist_fingerprint(&new_imgrecord, new_ansi_nist,
imgrecord_i);
if (ret < 0)
exit(EXIT_FAILURE);
else if (ret > 0) {
if (insert_ANSI_NIST_record_frmem(imgrecord_i, new_imgrecord,
new_ansi_nist))
exit(EXIT_FAILURE);
if (delete_ANSI_NIST_record(imgrecord_i+1, new_ansi_nist))
exit(EXIT_FAILURE);
}
}
if (insert_parsefing(new_ansi_nist, imgrecord_i,
img_fgp, fing_boxes, nf, rot_search))
exit(EXIT_FAILURE);
}
if (output_images) {
/* write_parsefing calls fileroot, which is destructive */
strcpy(filename, ifile);
if (write_parsefing(basename(filename), imgrecord_i, img_fgp, comp,
ppi, lossyflag, pdata, fing_boxes, nf, rot_seg))
exit(EXIT_FAILURE);
}
/* clean up before the next time around */
free(data);
free(fing_boxes);
for(i = 0; i < nf; i++)
free(pdata[i]);
free(pdata);
}
if (0 == matches)
fprintf(stderr, "WARNING : nfseg : no images match the criteria\n");
if (ret < 0)
exit(EXIT_FAILURE);
if (ofile != NULL && write_ANSI_NIST_file(ofile, new_ansi_nist) < 0)
exit(EXIT_FAILURE);
}
return(EXIT_SUCCESS);
}
int main( int argc, char **argv)
{
int ret;
int rawflag; /* raw input data or Ihead image */
char *outext; /* ouput file extension */
char *ifile, ofile[MAXPATHLEN]; /* file names */
int ilen;
int width, height; /* image parameters */
int depth, ppi;
unsigned char *idata, *odata; /* image pointers */
int lossyflag; /* data loss flag */
NISTCOM *nistcom; /* NIST Comment */
char *ppi_str;
procargs(argc, argv, &outext, &ifile, &rawflag);
ret = read_raw_from_filesize(ifile, &idata, &ilen);
if(ret)
exit(ret);
ret = wsq_decode_mem(&odata, &width, &height, &depth, &ppi, &lossyflag, idata, ilen);
if(ret){
free(idata);
exit(ret);
}
if(debug > 1)
fprintf(stderr, "Image pixmap constructed\n");
fileroot(ifile);
sprintf(ofile, "%s.%s", ifile, NCM_EXT);
/* Get NISTCOM from compressed data file */
ret = getc_nistcom_wsq(&nistcom, idata, ilen);
if(ret){
free(idata);
exit(ret);
}
free(idata);
/* WSQ decoder always returns ppi=-1, so believe PPI in NISTCOM, */
/* if it already exists. */
ppi_str = (char *)NULL;
if(nistcom != (NISTCOM *)NULL){
ret = extractfet_ret(&ppi_str, NCM_PPI, nistcom);
if(ret){
free(odata);
freefet(nistcom);
exit(ret);
}
}
if(ppi_str != (char *)NULL){
ppi = atoi(ppi_str);
free(ppi_str);
}
/* Combine NISTCOM with image features */
ret = combine_wsq_nistcom(&nistcom, width, height, depth, ppi, lossyflag,
0.0 /* will be deleted next */);
if(ret){
free(odata);
if(nistcom != (NISTCOM *)NULL)
freefet(nistcom);
exit(ret);
}
ret = del_wsq_nistcom(nistcom);
if(ret){
free(odata);
freefet(nistcom);
exit(ret);
}
/* Write NISTCOM */
ret = writefetfile_ret(ofile, nistcom);
if(ret){
free(odata);
freefet(nistcom);
exit(ret);
}
freefet(nistcom);
/* Write decoded image file. */
sprintf(ofile, "%s.%s", ifile, outext);
ret = write_raw_or_ihead(!rawflag, ofile, odata, width, height, depth, ppi);
if(ret){
free(odata);
exit(ret);
}
free(odata);
if(debug > 1)
fprintf(stdout, "Image pixmap written to %s\n", ofile);
exit(0);
}
int
main(int argc, char *argv[])
{
struct stackmark smark, smark2;
volatile int state;
char *shinit;
(void) setlocale(LC_ALL, "");
initcharset();
state = 0;
if (setjmp(main_handler.loc)) {
switch (exception) {
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
reset();
if (exception == EXINT)
out2fmt_flush("\n");
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
rootshell = 1;
init();
setstackmark(&smark);
setstackmark(&smark2);
procargs(argc, argv);
pwd_init(iflag);
if (iflag)
chkmail(1);
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
if (privileged == 0)
read_profile("${HOME-}/.profile");
else
read_profile("/etc/suid_profile");
}
state2:
state = 3;
if (!privileged && iflag) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(shinit);
}
}
state3:
state = 4;
popstackmark(&smark2);
if (minusc) {
evalstring(minusc, sflag ? 0 : EV_EXIT);
}
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
}
exitshell(exitstatus);
/*NOTREACHED*/
return 0;
}
int main(int argc, char *argv[])
{
int ret, n, rawflag;
char *outext; /* ouput file extension */
char *ifile, ofile[MAXPATHLEN]; /* file names */
FILE *outfp; /* output file pointer */
int width, height, depth, ppi, ilen, olen; /* image parameters */
unsigned char *idata, *odata; /* image pointers */
int hor_sampfctr[MAX_CMPNTS], vrt_sampfctr[MAX_CMPNTS];
int n_cmpnts;
int fsize;
procargs(argc, argv, &outext, &ifile,
&width, &height, &depth, &ppi, &rawflag,
hor_sampfctr, vrt_sampfctr, &n_cmpnts);
if((ret = filesize(ifile)) < 0)
exit(ret);
fsize = ret;
if((ret = test_image_size(fsize, width, height, hor_sampfctr,
vrt_sampfctr, n_cmpnts, 0)))
exit(ret);
if((ret = read_raw_from_filesize(ifile, &idata, &ilen)))
exit(ret);
if(debug > 0)
fprintf(stdout, "File %s read\n", ifile);
if((ret = not2intrlv_mem(&odata, &olen, idata, width, height, depth,
hor_sampfctr, vrt_sampfctr, n_cmpnts))){
free(idata);
exit(ret);
}
free(idata);
if(debug > 0)
fprintf(stdout, "Image data converted to interleaved\n");
/* Write interleaved image file. */
fileroot(ifile);
sprintf(ofile, "%s.%s", ifile, outext);
/* If H,V's are specified on command line, then YCbCr ... */
/* so write a raw output file. */
if(argc == 7){
if((outfp = fopen(ofile, "wb")) == NULL) {
fprintf(stderr, "ERROR: main : fopen : %s\n",ofile);
free(odata);
exit(-5);
}
if((n = fwrite(odata, 1, olen, outfp)) != olen){
fprintf(stderr, "ERROR: main : fwrite : ");
/* MDG added '%' to 's' to fix syntax error on 05/09/2005 */
fprintf(stderr, "only %d of %d bytes written from file %s\n",
n, olen, ofile);
free(odata);
exit(-6);
}
fclose(outfp);
}
/* Otherwise, H,V's not specified on command line, so component planes */
/* are all the same size ... so "possibly" write an IHead file. */
else{
if((ret = write_raw_or_ihead(!rawflag, ofile,
odata, width, height, depth, ppi))){
free(odata);
exit(ret);
}
}
if(debug > 0)
fprintf(stdout, "Image data written to file %s\n", ofile);
free(odata);
exit(0);
}
int
main(int argc, char **argv)
{
char *shinit;
volatile int state;
struct jmploc jmploc;
struct stackmark smark;
int login;
int i;
for (i = 1; i < argc; i++) {
if (0 == strcmp(argv[i], "--help") ||
0 == strcmp(argv[i], "-h")) {
sxsh_print_usage();
return (0);
}
if (0 == strcmp(argv[i], "--version") ||
0 == strcmp(argv[i], "-v")) {
sxsh_print_version();
return (0);
}
}
#ifdef __GLIBC__
dash_errno = __errno_location();
#endif
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
state = 0;
if (unlikely(setjmp(jmploc.loc))) {
int e;
int s;
reset();
e = exception;
s = state;
if (e == EXEXIT || s == 0 || iflag == 0 || shlvl)
exitshell();
if (e == EXINT
#if ATTY
&& (! attyset() || equal(termval(), "emacs"))
#endif
) {
out2c('\n');
#ifdef FLUSHERR
flushout(out2);
#endif
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (s == 1)
goto state1;
else if (s == 2)
goto state2;
else if (s == 3)
goto state3;
else
goto state4;
}
handler = &jmploc;
#ifdef DEBUG
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
init();
setstackmark(&smark);
login = procargs(argc, argv);
if (login) {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
read_profile("$HOME/.profile");
}
state2:
state = 3;
if (
#ifndef linux
getuid() == geteuid() && getgid() == getegid() &&
#endif
iflag
) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
read_profile(shinit);
}
}
popstackmark(&smark);
state3:
state = 4;
if (minusc)
evalstring(minusc, sflag ? 0 : EV_EXIT);
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
}
#if PROFILE
monitor(0);
#endif
#if GPROF
{
extern void _mcleanup(void);
_mcleanup();
}
#endif
exitshell();
/* NOTREACHED */
}
int
main(int argc, char **argv)
{
struct jmploc jmploc;
struct stackmark smark;
volatile int state;
char *shinit;
setlocale(LC_ALL, "");
/* Just a --version for show. */
if (argc > 1
&& argv[1][0] == '-'
&& argv[1][1] == '-') {
if (!strcmp(&argv[1][2], "version")) {
printf("kmk_ash - kBuild version %d.%d.%d\n",
KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR, KBUILD_VERSION_PATCH);
return 0;
}
if (!strcmp(&argv[1][2], "help")) {
printf("usage: kmk_ash [-aCefnuvxIimqVEb] [+aCefnuvxIimqVEb] [-o option_name]\n"
" [+o option_name] [command_file [argument ...]]\n"
" or: kmk_ash -c [-aCefnuvxIimqVEb] [+aCefnuvxIimqVEb] [-o option_name]\n"
" [+o option_name] command_string [command_name [argument ...]]\n"
" or: kmk_ash -s [-aCefnuvxIimqVEb] [+aCefnuvxIimqVEb] [-o option_name]\n"
" [+o option_name] [argument ...]\n"
" or: kmk_ash --help\n"
" or: kmk_ash --version\n",
argv[0], argv[0], argv[0], argv[0], argv[0]);
return 0;
}
}
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
state = 0;
if (setjmp(jmploc.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (exception) {
case EXSHELLPROC:
rootpid = getpid();
rootshell = 1;
minusc = NULL;
state = 3;
break;
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (exception != EXSHELLPROC) {
if (state == 0 || iflag == 0 || ! rootshell)
exitshell(exitstatus);
}
reset();
if (exception == EXINT
#if ATTY
&& (! attyset() || equal(termval(), "emacs"))
#endif
) {
out2c('\n');
flushout(&errout);
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &jmploc;
#ifdef DEBUG
#if DEBUG == 2
debug = 1;
#endif
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
rootshell = 1;
#ifdef _MSC_VER
{
extern void init_syntax(void);
init_syntax();
}
#endif
init();
setstackmark(&smark);
procargs(argc, argv);
if (argv[0] && argv[0][0] == '-') {
state = 1;
#ifndef KMK
read_profile("/etc/profile");
#endif
state1:
state = 2;
#ifndef KMK
read_profile(".profile");
#endif
}
state2:
state = 3;
#ifndef KMK
if (getuid() == geteuid() && getgid() == getegid()) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(shinit);
}
}
#endif
state3:
state = 4;
if (sflag == 0 || minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
int i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(sigs[i], 0);
}
if (minusc)
evalstring(minusc, 0);
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
}
#if PROFILE
monitor(0);
#endif
exitshell(exitstatus);
/* NOTREACHED */
}
int main(int argc, char **argv)
{
int ret, sd_id;
char *outext, *ifile, ofile[MAXPATHLEN];
FILE *infp;
IHEAD *ihead;
int width, height, depth, ppi;
unsigned char *tidata, *idata, *odata, *ocdata;
int i, complen, olen, oclen;
IMG_DAT *img_dat;
NISTCOM *nistcom;
char *comment_text;
int sampfctr;
procargs(argc, argv, &sd_id, &outext, &ifile);
infp = fopen(ifile, "rb");
if(infp == (FILE *)NULL) {
fprintf(stderr, "Error opening file %s for reading\n", ifile);
exit(-2);
}
ihead = readihdr(infp);
if(ihead == (IHEAD *)NULL) {
fprintf(stderr, "Error reading IHEAD header\n");
exit(-3);
}
sscanf(ihead->height,"%d", &height);
sscanf(ihead->width,"%d", &width);
sscanf(ihead->depth,"%d", &depth);
sscanf(ihead->density,"%d", &ppi);
sscanf(ihead->complen,"%d", &complen);
/* Construct NISTCOM */
if((ret = sd_ihead_to_nistcom(&nistcom, ihead, sd_id))){
free(ihead);
exit(ret);
}
free(ihead);
if(sd_id == 14){
if((ret = combine_wsq_nistcom(&nistcom, width, height, depth, ppi,
1, -1.0 /* unknown bitrate */))){
freefet(nistcom);
exit(ret);
}
}
else{
if((ret = combine_jpegl_nistcom(&nistcom, width, height, depth, ppi,
0, 1, (int *)NULL, (int *)NULL, 0, PRED4))){
freefet(nistcom);
exit(ret);
}
}
/* Convert NISTCOM to string. */
if((ret = fet2string(&comment_text, nistcom))){
freefet(nistcom);
exit(ret);
}
freefet(nistcom);
/* Switch on converter, supplying a NISTCOM ... */
/* If SD14 ... WSQ convert. */
if(sd_id == 14){
/* Convert image data to new format in memory. */
if((ret = wsq14_2_wsq(&odata, &olen, infp))) {
fclose(infp);
free(comment_text);
exit(ret);
}
fclose(infp);
/* Add comment text into new data format stream. */
if((ret = add_comment_wsq(&ocdata, &oclen, odata, olen,
(unsigned char *)comment_text))){
free(odata);
free(comment_text);
exit(ret);
}
free(odata);
odata = ocdata;
olen = oclen;
}
/* Otherwise, SD 4,9,10,18 ... JPEGL convert. */
else{
if((tidata = (unsigned char *)malloc(complen)) == (unsigned char *)NULL){
fprintf(stderr, "ERROR : %s : malloc : tidata\n", argv[0]);
exit(-4);
}
i = fread(tidata, sizeof(unsigned char), complen, infp);
if(i != complen) {
fprintf(stderr, "Error reading compressed data from %s\n", ifile);
free(tidata);
exit(-5);
}
fclose(infp);
if(debug > 0)
fprintf(stdout, "File %s read\n", ifile);
if((idata = (unsigned char *)malloc(width*height))==(unsigned char *)NULL){
fprintf(stderr, "ERROR : %s : malloc : idata\n", argv[0]);
free(tidata);
free(comment_text);
exit(-6);
}
if((ret = jpegl_sd4_decode_mem(tidata, complen,
width, height, depth, idata))){
free(tidata);
free(comment_text);
free(idata);
exit(ret);
}
free(tidata);
if(debug > 0){
fprintf(stdout, "Done decode JPEGL SD4 image\n");
fprintf(stdout, "Starting JPEGL compression\n");
}
/* Used to setup integer array of length 1 initialized to 1. */
sampfctr = 1;
if((ret = setup_IMG_DAT_nonintrlv_encode(&img_dat, idata,
width, height, depth, ppi,
&sampfctr, &sampfctr, 1,
0, PRED4))) {
free(comment_text);
free(idata);
exit(ret);
}
if(debug > 0)
fprintf(stdout, "Image structure initialized\n");
if((ret = jpegl_encode_mem(&odata, &olen, img_dat, comment_text))){
free(comment_text);
free_IMG_DAT(img_dat, FREE_IMAGE);
exit(ret);
}
free(comment_text);
free_IMG_DAT(img_dat, FREE_IMAGE);
}
if(debug > 0)
fprintf(stdout, "Image data converted, reformatted byte length = %d\n",
olen);
/* Write reformatted file. */
fileroot(ifile);
sprintf(ofile, "%s.%s", ifile, outext);
if((ret = write_raw_from_memsize(ofile, odata, olen))){
free(odata);
exit(ret);
}
if(debug > 0)
fprintf(stdout, "Image data written to file %s\n", ofile);
free(odata);
exit(0);
}
int main(int argc, char *argv[])
{
int ret, rawflag, img_type;
unsigned char *idata, *odata;
int ilen, width, height, depth, ppi, lossyflag;
IHEAD *ihead;
FILE *fp;
char *outext, *ifile, ofile[MAXPATHLEN];
NISTCOM *nistcom;
procargs(argc, argv, &outext, &ifile, &rawflag);
/* Set ppi to unknown */
ppi = -1;
nistcom = (NISTCOM *)NULL;
/* Check image type */
ret = read_raw_from_filesize(ifile, &idata, &ilen);
if(ret)
exit(ret);
ret = image_type(&img_type, idata, ilen);
if(ret) {
free(idata);
exit(ret);
}
free(idata);
/* Open image file for reading based on image type */
if((fp = fopen(ifile,"rb")) == NULL) {
fprintf(stderr, "ERROR: main : fopen : %s\n",ifile);
exit(-1);
}
/* If img_type is ihead ... */
if(img_type == IHEAD_IMG){
/* Read ihead header and check for WSQ_SD14 compression */
ihead = readihdr(fp);
if(atoi(ihead->compress) != WSQ_SD14){
fprintf(stderr, "ERROR : main : input image not WSQ_SD14 compressed\n");
fprintf(stderr, " compression = %d, WSQ_SD14 = %d\n",
atoi(ihead->compress), WSQ_SD14);
fclose(fp);
free(ihead);
exit(-1);
}
/* Get ppi from ihead header */
sscanf(ihead->density,"%d", &ppi);
/* Create a nistcom for the image attributes */
ret = sd_ihead_to_nistcom(&nistcom, ihead, 14);
if(ret) {
fclose(fp);
free(ihead);
exit(ret);
}
free(ihead);
}
/* If image not WSQ_IMG or IHEAD_IMG, ERROR!!! */
else if(img_type != WSQ_IMG) {
fprintf(stderr, "ERROR : main : Invalid image\n");
fprintf(stderr, "Expected a WSQ_SD14 compressed image in\n");
fprintf(stderr, "either raw or ihead format.\n");
fclose(fp);
exit(-1);
}
/* Decode compressed image */
ret = wsq14_decode_file(&odata, &width, &height, &depth, &lossyflag, fp);
if(ret){
fclose(fp);
if(img_type == IHEAD_IMG)
freefet(nistcom);
exit(ret);
}
fclose(fp);
if(debug > 1)
fprintf(stderr, "Image pixmap constructed\n");
/* Combine image attributes into current nistcom */
ret = combine_wsq_nistcom(&nistcom, width, height, depth, ppi, lossyflag, -1.0);
if(ret){
if(img_type == IHEAD_IMG)
freefet(nistcom);
free(odata);
exit(ret);
}
ret = del_wsq_nistcom(nistcom);
if(ret){
free(odata);
freefet(nistcom);
exit(ret);
}
fileroot(ifile);
sprintf(ofile, "%s.%s", ifile, NCM_EXT);
/* Write NISTCOM */
ret = writefetfile_ret(ofile, nistcom);
if(ret){
freefet(nistcom);
free(odata);
exit(ret);
}
freefet(nistcom);
/* Write decompressed image */
sprintf(ofile, "%s.%s", ifile, outext);
ret = write_raw_or_ihead(!rawflag, ofile, odata, width, height, depth, ppi);
if(ret){
free(odata);
exit(ret);
}
free(odata);
if(debug > 1)
fprintf(stderr, "Image pixmap written to %s\n", ofile);
exit(0);
}
int main(int argc, char *argv[])
{
int ret, rawflag;
char *outext; /* ouput file extension */
char *ifile, ofile[MAXPATHLEN]; /* file names */
int width, height, depth, ppi, ilen, olen; /* image parameters */
IHEAD *ihead;
unsigned char *idata, *odata; /* image pointers */
int hor_sampfctr[MAX_CMPNTS], vrt_sampfctr[MAX_CMPNTS];
int n_cmpnts;
procargs(argc, argv, &outext, &ifile, &rawflag,
&width, &height, &depth, &ppi,
hor_sampfctr, vrt_sampfctr, &n_cmpnts);
/* If H,V's are specified on command line, then YCbCr ... */
/* so read a raw input file. */
if(argc == 7){
if((ret = read_raw_from_filesize(ifile, &idata, &ilen)))
exit(ret);
if((ret = test_image_size(ilen, width, height, hor_sampfctr,
vrt_sampfctr, n_cmpnts, 1)))
exit(ret);
}
else{
/* If raw image flagged... */
if(rawflag) {
if((ret = read_raw(ifile, &idata, &width, &height, &depth)))
exit(ret);
}
/* Otherwise, input image is an IHead image */
else {
if((ret = read_ihead(ifile, &ihead, &idata, &width, &height, &depth)))
exit(ret);
}
}
if(debug > 0)
fprintf(stdout, "File %s read\n", ifile);
/* If IHead image file ... */
if(!rawflag){
/* Get PPI from IHead. */
ppi = get_density(ihead);
free(ihead);
}
if((ret = intrlv2not_mem(&odata, &olen, idata, width, height, depth,
hor_sampfctr, vrt_sampfctr, n_cmpnts))){
free(idata);
exit(ret);
}
free(idata);
if(debug > 0)
fprintf(stdout, "Image data converted to non-interleaved\n");
fileroot(ifile);
sprintf(ofile, "%s.%s", ifile, outext);
if((ret = write_raw_from_memsize(ofile, odata, olen))){
free(odata);
exit(ret);
}
if(debug > 0)
fprintf(stdout, "Image data written to file %s\n", ofile);
free(odata);
exit(0);
}
int
main(int argc, char **argv)
{
struct stackmark smark;
volatile int state;
char *shinit;
uid_t uid;
gid_t gid;
uid = getuid();
gid = getgid();
max_user_fd = fcntl(0, F_MAXFD);
if (max_user_fd < 2)
max_user_fd = 2;
setlocale(LC_ALL, "");
posix = getenv("POSIXLY_CORRECT") != NULL;
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
state = 0;
if (setjmp(main_handler.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (exception) {
case EXSHELLPROC:
rootpid = getpid();
rootshell = 1;
minusc = NULL;
state = 3;
break;
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (exception != EXSHELLPROC) {
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
}
reset();
if (exception == EXINT) {
out2c('\n');
flushout(&errout);
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
#if DEBUG >= 2
debug = 1; /* this may be reset by procargs() later */
#endif
opentrace();
trputs("Shell args: "); trargs(argv);
#if DEBUG >= 3
set_debug(((DEBUG)==3 ? "_@" : "++"), 1);
#endif
#endif
rootpid = getpid();
rootshell = 1;
init();
initpwd();
setstackmark(&smark);
procargs(argc, argv);
/*
* Limit bogus system(3) or popen(3) calls in setuid binaries,
* by requiring the -p flag
*/
if (!pflag && (uid != geteuid() || gid != getegid())) {
setuid(uid);
setgid(gid);
/* PS1 might need to be changed accordingly. */
choose_ps1();
}
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
read_profile(".profile");
}
state2:
state = 3;
if ((iflag || !posix) &&
getuid() == geteuid() && getgid() == getegid()) {
struct stackmark env_smark;
setstackmark(&env_smark);
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(expandenv(shinit));
}
popstackmark(&env_smark);
}
state3:
state = 4;
line_number = 1; /* undo anything from profile files */
if (sflag == 0 || minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
size_t i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(sigs[i], 0);
}
if (minusc)
evalstring(minusc, sflag ? 0 : EV_EXIT);
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
if (iflag) {
out2str("\n");
flushout(&errout);
}
}
#if PROFILE
monitor(0);
#endif
line_number = plinno;
exitshell(exitstatus);
/* NOTREACHED */
}
int
main(int argc, char *argv[])
{
struct stackmark smark, smark2;
volatile int state;
char *shinit;
#ifdef CBSD
char *MY_APP = NULL;
char *cbsdpath = NULL;
char *workdir = NULL;
char *cbsd_disable_history = NULL; //getenv
chdir("/var/empty");
/* Only use history when stdin is a tty. */
if ( isatty(0) && isatty(1) ) {
cbsd_enable_history = 1;
}
#endif
(void) setlocale(LC_ALL, "");
initcharset();
state = 0;
if (setjmp(main_handler.loc)) {
switch (exception) {
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
reset();
if (exception == EXINT)
out2fmt_flush("\n");
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
rootshell = 1;
INTOFF;
initvar();
setstackmark(&smark);
setstackmark(&smark2);
#ifdef CBSD
if (argc>1) {
if (!strcmp(argv[1],"--help")) {
system("/usr/local/bin/cbsd help");
exit(0);
} else {
if (!strcmp(argv[1],"version")) {
printf("%s\n",VERSION);
exit(0);
}
}
}
cbsd_disable_history=lookupvar("NO_CBSD_HISTORY");
if ( cbsd_disable_history != NULL ) cbsd_enable_history=0;
workdir=lookupvar("workdir");
if ( workdir == NULL ) {
read_profile("/etc/rc.conf");
setvarsafe("workdir", lookupvar("cbsd_workdir"), 0);
}
workdir=lookupvar("workdir");
if ( workdir == NULL ) {
out2fmt_flush("cbsd: no workdir defined\n");
exitshell(1);
}
setvarsafe("PS1","cbsd@\\h> ",1);
setvarsafe("workdir",workdir,1);
workdir=lookupvar("workdir"); // ^^ after "setsave*" original is free
cbsdpath = calloc(MAXPATHLEN, sizeof(char *));
if (argv[1]) {
setvarsafe("CBSD_APP",basename(argv[1]),1);
}
if (cbsdpath == NULL) {
out2fmt_flush("cbsd: out of memory for cbsdpath\n");
exitshell(1);
}
// %s/modules must be first for opportunity to have a module commands greater priority than the original CBSD command.
// This makes it possible to write a 3rd party modules with altered functionality of the original code.
sprintf(cbsdpath,"%s/modules:%s/bin:%s/sbin:%s/tools:%s/jailctl:%s/nodectl:%s/system:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin",workdir,cbsd_distdir,cbsd_distdir,cbsd_distdir,cbsd_distdir,cbsd_distdir,cbsd_distdir);
setvarsafe("PATH",cbsdpath,1);
ckfree(cbsdpath);
// read global params first (disable/enable colors, repos etc..)
read_profile("${workdir}/etc/defaults/global.conf");
read_profile("${workdir}/etc/global.conf");
if (lookupvar("NOCOLOR") != NULL ) {
putenv("NOCOLOR=1");
}
// non-interactive global env
if (lookupvar("NOINTER") != NULL ) {
setvarsafe("inter","1",1);
putenv("inter=0");
}
read_profile("/usr/local/cbsd/cbsd.conf");
read_profile("${workdir}/etc/defaults/logger.conf");
read_profile("${workdir}/etc/logger.conf");
if (cbsd_enable_history==1) {
cbsd_history_file=calloc(MAXPATHLEN, sizeof(char *));
sprintf(cbsd_history_file,"%s/%s",workdir,CBSD_HISTORYFILE);
}
#endif
procargs(argc, argv);
pwd_init(iflag);
INTON;
#ifndef CBSD
if (iflag)
chkmail(1);
#endif
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
if (privileged == 0)
read_profile("${HOME-}/.profile");
else
read_profile("/etc/suid_profile");
}
state2:
state = 3;
if (!privileged && iflag) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(shinit);
}
}
state3:
state = 4;
popstackmark(&smark2);
if (minusc) {
evalstring(minusc, sflag ? 0 : EV_EXIT);
}
state4:
if (sflag || minusc == NULL) {
cmdloop(1);
}
exitshell(exitstatus);
/*NOTREACHED*/
return 0;
}
SH_NORETURN_1 void
shell_main(shinstance *psh, int argc, char **argv)
{
struct jmploc jmploc;
struct stackmark smark;
volatile int state;
char *shinit;
state = 0;
if (setjmp(jmploc.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (psh->exception) {
case EXSHELLPROC:
psh->rootpid = /*getpid()*/ psh->pid;
psh->rootshell = 1;
psh->minusc = NULL;
state = 3;
break;
case EXEXEC:
psh->exitstatus = psh->exerrno;
break;
case EXERROR:
psh->exitstatus = 2;
break;
default:
break;
}
if (psh->exception != EXSHELLPROC) {
if (state == 0 || iflag(psh) == 0 || ! psh->rootshell)
exitshell(psh, psh->exitstatus);
}
reset(psh);
if (psh->exception == EXINT
#if ATTY
&& (! attyset(psh) || equal(termval(psh), "emacs"))
#endif
) {
out2c(psh, '\n');
flushout(&psh->errout);
}
popstackmark(psh, &smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
psh->handler = &jmploc;
psh->rootpid = /*getpid()*/ psh->pid;
psh->rootshell = 1;
#ifdef DEBUG
#if DEBUG == 2
debug(psh) = 1;
#endif
opentrace(psh);
trputs(psh, "Shell args: "); trargs(psh, argv);
#endif
init(psh);
setstackmark(psh, &smark);
procargs(psh, argc, argv);
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile(psh, "/etc/profile");
state1:
state = 2;
read_profile(psh, ".profile");
}
state2:
state = 3;
if (sh_getuid(psh) == sh_geteuid(psh) && sh_getgid(psh) == sh_getegid(psh)) {
if ((shinit = lookupvar(psh, "ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(psh, shinit);
}
}
state3:
state = 4;
if (sflag(psh) == 0 || psh->minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
unsigned i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(psh, sigs[i], 0);
}
if (psh->minusc)
evalstring(psh, psh->minusc, 0);
if (sflag(psh) || psh->minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(psh, 1);
}
exitshell(psh, psh->exitstatus);
/* NOTREACHED */
}
