int main(int argc, char **argv) {
if (argc == 1 || (argc ==2 && !strcmp(argv[1]," -h") )) {
printf("Usage : %s src output\n", argv[0]);
return 0;
} else if (argc != 2) {
printf("invalid number of argument\n");
return -1;
}
int fp1_len = strlen(argv[1]);
int i;
for(i = fp1_len - 1; i >= 0; i--) {
if (argv[1][i] == '.') {
i++;
break;
}
if (i == 0) {
printf("%s : file type unknown\n", argv[1]);
exit_func(-1);
}
}
if (!strcmp(argv[1] + i, "c")) {
c_main(argv[1]);
} else {
printf("%s : file type unknown\n", argv[1]);
exit_func(-1);
}
return 0;
}
int main ()
{
bcm_host_init();
printf("Note: ensure you have sufficient gpu_mem configured\n");
// Clear application state
memset( state, 0, sizeof( *state ) );
// Start OGLES
init_ogl(state);
// Setup the model world
init_model_proj(state);
// initialise the OGLES texture(s)
init_textures(state);
while (!terminate)
{
update_model(state);
redraw_scene(state);
}
exit_func();
return 0;
}
void sig_func( int signo )
{
if ( verbose_level )
fprintf( stderr, "\n[%s] got signo %d, bye.\n\n", par.progname, signo );
exit_func( 1 );
}
int main (int argc, char *argv[])
{
bcm_host_init();
// Clear application state
memset( state, 0, sizeof( *state ) );
setup_user_options(argc, argv);
// Start OGLES
init_egl();
init_textures();
build_gears();
// setup the scene based on rendering mode
if (state->useGLES2) {
init_scene_GLES2();
// Setup the model projection/world
init_model_projGLES2();
}
else { // using gles1
init_scene_GLES1();
// Setup the model projection/world
init_model_projGLES1();
}
// animate the gears
run_gears();
exit_func();
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
init_func();
Compute();
exit_func();
return 0;
}
static void merge(void *left, size_t size, size_t l_len, void *right,
size_t r_len, void *output, Comparator cmp)
{
char *l_pos = left;
char *r_pos = right;
char *l_end = l_pos + l_len * size;
char *r_end = r_pos + r_len * size;
char *o_pos = output;
enter_func(__func__);
while (r_pos < r_end && l_pos < l_end)
{
if ((*cmp)(r_pos, l_pos) < 0)
{
memmove(o_pos, r_pos, size);
o_pos += size;
r_pos += size;
}
else
{
memmove(o_pos, l_pos, size);
o_pos += size;
l_pos += size;
}
}
/* Only one of these conditions is active */
if (r_pos < r_end)
memmove(o_pos, r_pos, r_end - r_pos);
if (l_pos < l_end)
memmove(o_pos, l_pos, l_end - l_pos);
exit_func(__func__);
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int main (int argc, char* argv[])
{
nameslist_t list; // Namensliste mit allen Zusatzinfos
phops_t phops; // Optionen Phonetik
frmops_t frmops; // Optionen Formatierung
outops_t outops; // Optionen Ausgabemodus
int stat; // Stausnummer... wird ans BS durchgereicht
// Falls keine Argumente übergeben, Konvertierroutine aufrufen
// Gibt Statuskonstannte für exit_func zurück
if (argc == 1) {
stat = printout_convert();
exit_func (stat);
}
// Optionen aus Übergabe erstellen, gibt STAT_SUCCESS oder Fehlerkonstannte zurück
stat = parse_options (argc, argv, &phops, &frmops, &outops);
if (stat != STAT_SUCCESS) exit_func (stat);
// Übergebene Namen zählen... gibt 0 zurück wenn Keine, sonst Anzahl 1...n
list.number_of_names = parser_count_names(argc, argv);
if (list.number_of_names == 0) {
stat = STAT_ERR_PARAM;
exit_func (stat);
}
// Namensarray dimensionieren nach Anzahl... mit Liste verknüpfen
name_t names[list.number_of_names];
list.items = names;
// Namensliste (list) füllen, Funktion gibt STAT_SUCCESS oder Fehlerkonstannte zurück
stat = parser_fill_nameslist(argc, argv, &list);
if (stat != STAT_SUCCESS) exit_func (stat);
// Anzeigeroutine anspringen, wenn mehrere gewählt
// gewinnt die, mit mehr Textausgabe... Funktion gibt Statuskonstannte für exit_func zurück
if (outops.a == true) stat = printout_a (&list, &phops, &frmops);
else if (outops.z == true) stat = printout_z (&list, &phops, &frmops);
else if (outops.w == true) stat = printout_w (&list, &phops, &frmops);
else stat = printout_c (&list, & phops, &frmops);
exit_func (stat);
// Wird nie erreicht
return 255;
}
void exit(int code)
{
/* call exit funcs */
#ifdef ATEXIT_SINGLE
if(exit_func)
exit_func();
#else
while(exit_fidx > 0)
exit_funcs[--exit_fidx]();
#endif
__syscall(SYS_exit, code);
}
int find_pwd(char **envp)
{
int i;
i = 0;
while (envp[i])
{
if (my_strncmp(envp[i], "PWD", 3) == 0)
return (i);
++i;
}
exit_func("Error: PWD doesn't exist in PATH.\n");
return (0);
}
void merge_sort(void *array, size_t arrlen, size_t size, Comparator cmp)
{
if (arrlen <= 1)
return;
char *base = array;
size_t mid = arrlen / 2;
size_t l_len = mid;
size_t r_len = arrlen - mid;
char l_data[l_len * size];
char r_data[r_len * size];
enter_func(__func__);
memmove(l_data, base, l_len * size);
memmove(r_data, base + l_len * size, r_len * size);
merge_sort(l_data, l_len, size, cmp);
merge_sort(r_data, r_len, size, cmp);
merge(l_data, size, l_len, r_data, r_len, array, cmp);
exit_func(__func__);
}
static void merge(int *left, size_t l_len, int *right, size_t r_len, int *output)
{
size_t r_pos = 0;
size_t l_pos = 0;
size_t o_pos = 0;
enter_func(__func__);
dump_array("Left:", left, l_len);
dump_array("Right:", right, r_len);
while (r_pos < r_len && l_pos < l_len)
{
if (right[r_pos] < left[l_pos])
output[o_pos++] = right[r_pos++];
else
output[o_pos++] = left[l_pos++];
}
while (r_pos < r_len)
output[o_pos++] = right[r_pos++];
while (l_pos < l_len)
output[o_pos++] = left[l_pos++];
dump_array("Output:", output, r_len + l_len);
exit_func(__func__);
}
int _main ()
{
bcm_host_init();
// Clear application state
memset( state, 0, sizeof( *state ) );
// Start OGLES
init_ogl(state);
// Setup the model world
init_model_proj(state);
// initialise the OGLES texture(s)
init_textures(state);
while (!terminate)
{
update_model(state);
redraw_scene(state);
}
exit_func();
return 0;
}
void merge_sort(int *array, size_t len)
{
if (len <= 1)
return;
int left[(len+1)/2];
int l_pos = 0;
int right[(len+1)/2];
int r_pos = 0;
size_t mid = len / 2;
enter_func(__func__);
dump_array("Input:", array, len);
for (size_t i = 0; i < mid; i++)
left[l_pos++] = array[i];
for (size_t i = mid; i < len; i++)
right[r_pos++] = array[i];
dump_array("Left:", left, l_pos);
dump_array("Right:", right, r_pos);
merge_sort(left, l_pos);
merge_sort(right, r_pos);
merge(left, l_pos, right, r_pos, array);
dump_array("Result:", array, len);
exit_func(__func__);
}
static int
usalo_close(SCSI *usalp)
{
exit_func();
return (0);
}
int main(int argc, char *argv[])
{
bcm_host_init();
// Start OGLES
init_ogl(state);
//////////////////////
// Setup vertices
/////////////////////
// Vertices
static const GLfloat vertices[] = {
-0.5f, 0.5f,
0.5f, 0.5f,
0.5f, -0.5f,
-0.5f, -0.5f
};
// Generate vertex buffer
GLuint vbo;
glGenBuffers(1, &vbo);
// Set buffer
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Fill buffer
glBufferData(GL_ARRAY_BUFFER, 2*4*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
// Elements
GLubyte elements[] = {
2, 3, 0,
0, 1, 2
};
// Generate element buffer
GLuint ebo;
glGenBuffers(1, &ebo);
// Set buffer
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
// Fill buffer
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*3*sizeof(GLubyte), elements, GL_STATIC_DRAW);
/////////////////////
// Setup shaders
////////////////////
// Compile vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
showlog(vertexShader);
// Compile frag shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
showlog(fragmentShader);
// Create shader program
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
// Link and use program
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
// Specify and enable vertex attribute
GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(posAttrib);
// Clear the screen
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Event loop
while(!terminate)
{
// Draw square
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
// Swap buffers
eglSwapBuffers(state->display, state->surface);
}
// Clean up before exit
exit_func();
return 0;
}
int main (int argc, char *argv[])
{
char arg; /* short options: character */
int loptidx=0; /* long options: arg==0 and index */
char opt[] = "64stuhl:p:vo:f:";
#ifdef HAVE_GETOPT_LONG
struct option lopt[] = {
{ "dbhost", 1, 0, 0},
{ "dbname", 1, 0, 0},
{ "dbuser", 1, 0, 0},
{ "dbpw", 1, 0, 0},
{ "db", 0, 0, 0},
{ "ssl", 0, 0, 0},
{ "key", 1, 0, 0},
{ "cert", 1, 0, 0},
{ "cafile", 1, 0, 0},
{ "cadir", 1, 0, 0},
{ "help", 0, 0, 0},
{ 0, 0, 0, 0 }
};
#endif
/** set default options
*/
par.tcp = 0;
par.udp = 0;
par.sctp = 0;
par.ssl = 0;
par.cafile = CAFILE;
par.cadir = CADIR;
par.keyfile = KEYFILE;
par.certfile= CERTFILE;
par.port = 0;
par.family = AF_UNSPEC;
par.logfile = NULL;
par.maxcon = 10;
par.datadir = NULL;
par.datafile = NULL;
par.dbexport = 0;
par.dbhost = DFLT_MYSQL_HOST;
par.dbname = DFLT_MYSQL_DBNAME;
par.dbuser = DFLT_MYSQL_USER;
par.dbpw = DFLT_MYSQL_PASSWORD;
snprintf( par.progname, sizeof(par.progname), "%s", basename( argv[0]) );
/* --- command line parsing ---
*/
#ifdef HAVE_GETOPT_LONG
while ((arg=getopt_long( argc, argv, opt, lopt, &loptidx)) >=0 )
#else
while( (arg=getopt( argc, argv, opt )) != EOF )
#endif
{
switch (arg)
{
case 0:
switch (loptidx) {
case 0: /* dbhost */
par.dbhost = optarg;
break;
case 1: /* dbname */
par.dbname = optarg;
break;
case 2: /* dbuser */
par.dbuser = optarg;
break;
case 3: /* dbpw */
par.dbpw = optarg;
break;
case 4: /* db */
par.dbexport = 1;
break;
case 5: /* ssl */
par.ssl = 1;
break;
case 6: /* key */
par.keyfile = optarg;
break;
case 7: /* cert */
par.certfile = optarg;
break;
case 8: /* cafile */
par.cafile = optarg;
break;
case 9: /* cadir */
par.cadir = optarg;
break;
case 10:
usage(par.progname);
exit(1);
}
break;
case '4':
#ifdef INET6
par.family = (par.family==AF_INET6)? AF_UNSPEC : AF_INET;
break;
case '6':
par.family = (par.family==AF_INET)? AF_UNSPEC : AF_INET6;
#endif
break;
case 'd':
par.dbexport = 1;
break;
case 'l':
par.logfile = optarg;
break;
case 's':
par.sctp ++;
break;
case 't':
par.tcp ++;
break;
case 'u':
par.udp ++;
break;
case 'o':
par.datadir = optarg;
if ( access( optarg, W_OK|X_OK ) <0 ) {
fprintf( stderr, "cannot access dir '%s': %s!\n",
optarg, strerror(errno) );
exit(1);
}
break;
case 'f':
par.datafile = optarg;
break;
case 'p':
if ((par.port=atoi(optarg)) <0)
{
fprintf( stderr, "Invalid -p argument!\n" );
exit(1);
}
break;
case 'v':
verbose_level ++;
break;
case 'h':
default:
usage(par.progname);
exit(1);
}
}
if ( !par.udp && !par.tcp && !par.sctp )
par.tcp++;
if ( !par.dbexport && !par.datadir ) {
fprintf( stderr, "info: message dump, no data storage.\n" );
fflush( stderr );
}
if ( par.port==0 ) {
par.port = par.ssl?IPFIX_TLS_PORTNO:IPFIX_PORTNO;
}
/** init loggin
*/
mlog_set_vlevel( verbose_level );
if ( par.logfile )
(void) mlog_open( par.logfile, NULL );
if ( (!par.dbexport && !par.datadir)
|| (verbose_level >2) )
(void) ipfix_col_start_msglog( stderr );
mlogf( 1, "[%s] listen on port %d, write to %s ...\n",
par.progname, par.port,
par.dbexport?"database":par.datadir?"files":"stdout" );
/** init ipfix lib
*/
if ( ipfix_init() <0 ) {
fprintf( stderr, "ipfix_init() failed: %s\n", strerror(errno) );
exit(1);
}
if ( ipfix_add_vendor_information_elements( ipfix_ft_fokus ) <0 ) {
fprintf( stderr, "ipfix_add_ie() failed: %s\n", strerror(errno) );
exit(1);
}
/** signal handler
signal( SIGSEGV, sig_func );
*/
signal( SIGKILL, sig_func );
signal( SIGTERM, sig_func );
signal( SIGINT, sig_func );
/** do the work
*/
if ( do_collect() <0 )
exit_func(1);
exit_func(0);
return 0;
}
int main (int argc, char *argv[])
{
char arg; /* short options: character */
int loptidx; /* long options: arg==0 and index */
extern int optind; /* actual option index, <=argc */
char opt[] = "hvdpl:i:r:c:f:stu";
struct option lopt[] = {
{ "version", 0, 0, 0},
{ "tidle", 1, 0, 0},
{ "tflow", 1, 0, 0},
{ "texport", 1, 0, 0},
{ "odid", 1, 0, 0},
{ "ssl", 0, 0, 0},
{ "key", 1, 0, 0},
{ "cert", 1, 0, 0},
{ "cafile", 1, 0, 0},
{ "cadir", 1, 0, 0},
{ "biflows", 0, 0, 0},
{ "maxflows", 1, 0, 0},
{ "help", 0, 0, 0},
{ 0, 0, 0, 0 }
};
/* set parameters to default values
*/
g_par.protocol = IPFIX_PROTO_TCP;
g_par.logfile = NULL;
g_par.interface[0] = '\0';
g_par.filter = NULL;
g_par.collector = "localhost";
g_par.port = 0;
g_par.flags = PROBE_PROMISC;
g_par.vlevel = 0;
g_par.odid = 1;
g_par.ipflow_timeout = 30;
g_par.ipflow_max = 25000;
g_par.ipflow_lifetime = 300;
g_par.biflows = 0;
g_par.export_timeout = 10;
g_par.ssl = 0;
g_par.cafile = CAFILE;
g_par.cadir = CADIR;
g_par.keyfile = KEYFILE;
g_par.certfile = CERTFILE;
snprintf( g_par.progname, sizeof(g_par.progname), "%s", basename(argv[0]) );
/* process command line options
*/
while ((arg=getopt_long(argc,argv,opt,lopt,&loptidx)) >=0) {
switch (arg) {
case 0:
switch (loptidx) {
case 0:
/* version */
mlogf( 0, "%s (%s, %s)\n",
PROBE_IDSTR, PROBE_VERSIONSTR, __DATE__ );
exit(0);
break;
case 1:
/* idle timeout */
sscanf( optarg, "%u", &g_par.ipflow_timeout );
break;
case 2:
/* flow lifetime */
sscanf( optarg, "%u", &g_par.ipflow_lifetime );
break;
case 3:
/* export interval */
sscanf( optarg, "%u", &g_par.export_timeout );
break;
case 4:
/* observation domain id */
sscanf( optarg, "%u", &g_par.odid );
break;
case 5: /* ssl */
g_par.ssl = 1;
break;
case 6: /* key */
g_par.keyfile = optarg;
break;
case 7: /* cert */
g_par.certfile = optarg;
break;
case 8: /* cafile */
g_par.cafile = optarg;
break;
case 9: /* cadir */
g_par.cadir = optarg;
break;
case 10: /* biflows */
g_par.biflows = 1;
break;
case 11: /* max number of flows */
sscanf( optarg, "%d", &g_par.ipflow_max );
break;
case 12:
usage(g_par.progname);
}
break;
case 'c':
g_par.collector = optarg;
break;
case 'd':
g_par.flags |= PROBE_DAEMON;
break;
case 'f':
if ((*optarg=='\'') || (*optarg=='"')) {
g_par.filter = strdup( optarg+1 );
g_par.filter[strlen(optarg)-1] = '\0';
}
else {
g_par.filter = strdup( optarg );
}
break;
case 'i':
if ( *(g_par.interface) ) {
fprintf( stderr, "warning: parameter '-i %s' ignored.\n",
optarg );
break;
}
snprintf( g_par.interface, PATH_MAX, "%s", optarg );
break;
case 'p':
g_par.flags &= ~PROBE_PROMISC;
break;
case 'r':
if ( *(g_par.interface) ) {
fprintf( stderr, "warning: parameter '-r %s' ignored.\n",
optarg );
break;
}
g_par.flags |= PROBE_OFFLINE;
if ( strcmp( optarg, "-" ) ==0 ) {
strcpy( g_par.interface, optarg );
}
else if ( realpath( optarg, g_par.interface ) ==NULL) {
fprintf( stderr, "cannot access file '%s': %s\n",
optarg, strerror(errno) );
exit(1);
}
break;
case 'l':
g_par.logfile = optarg;
break;
case 'h':
usage(g_par.progname);
break;
case 's':
g_par.protocol = IPFIX_PROTO_SCTP;
break;
case 't':
g_par.protocol = IPFIX_PROTO_TCP;
break;
case 'u':
g_par.protocol = IPFIX_PROTO_UDP;
break;
case 'v':
g_par.vlevel ++;
break;
default:
usage(argv[0]);
}
}/*parse opts*/
if (optind < argc) {
errorf ( "No additional parameters needed!\n");
exit(1);
}
if ( g_par.port==0 ) {
g_par.port = g_par.ssl?IPFIX_TLS_PORTNO:IPFIX_PORTNO;
}
/* init program */
if ( prog_init() <0 ) {
exit(1);
}
mlogf( 2, "[%s] program initialized.\n", g_par.progname );
/* do the work */
if ( probe_loop( &g_probe ) < 0 ) {
exit_func( 0 );
}
/* clean up */
exit_func ( 0 );
return 0;
} /* main */
