static void set_shader_source(wip24_state* state, const char* source) {
GLuint frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* sources[2] = {source_header, source};
glShaderSource(frag, 2, sources, NULL);
glCompileShader(frag);
GLint status;
glGetShaderiv(frag, GL_COMPILE_STATUS, &status);
if (!status) {
char log[1024];
glGetShaderInfoLog(frag, sizeof(log), NULL, log);
log_entry("Error: Unable to compile shader: %s\n", log);
glDeleteShader(frag);
return;
}
state->program = glCreateProgram();
glAttachShader(state->program, frag);
glLinkProgram(state->program);
glValidateProgram(state->program);
glDeleteShader(frag);
glGetProgramiv(state->program, GL_LINK_STATUS, &status);
if (!status) {
char log[1024];
glGetProgramInfoLog(state->program, sizeof(log), NULL, log);
log_entry("Error: Unable to link program: %s\n", log);
glDeleteProgram(state->program);
state->program = 0;
return;
}
}
ne_status
vkgfx_init_surface(void)
{
VkResult err = 0;
VkWin32SurfaceCreateInfoKHR ci;
PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = NULL;
memset(&ci, 0x0, sizeof(ci));
vkCreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)
vkGetInstanceProcAddr(vkgfx_instance, "vkCreateWin32SurfaceKHR");
if (!vkCreateWin32SurfaceKHR) {
log_entry(VK_WIN32_GFX_MODULE, LOG_CRITICAL,
"Vulkan instance missing VK_KHR_win32_surface extension");
return NE_FAIL;
}
ci.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
ci.hwnd = GetActiveWindow();
ci.hinstance = GetModuleHandle(NULL);
err = vkCreateWin32SurfaceKHR(vkgfx_instance, &ci, vkgfx_allocator, &vkgfx_surface);
if (err) {
log_entry(VK_WIN32_GFX_MODULE, LOG_CRITICAL,
"Failed to create Vulkan surface: %d", err);
return NE_FAIL;
}
return NE_OK;
}
int main(int argc, char **argv)
{
int result = 0;
Configuration *configuration = NULL;
logInit();
log_entry(LogVerbose, "Starting %s", argv[0]);
result = parse(argc, argv, &configuration);
if (result < 0)
{
usage();
return 1;
}
if (ConfigurationVersion(configuration))
{
char version[] = CF_UPGRADE_VERSION;
printf("cf-upgrade %s\n", version);
return 0;
}
if (ConfigurationHelp(configuration))
{
usage();
return 0;
}
result = RunUpdate(configuration);
log_entry(LogVerbose, "Finished %s", argv[0]);
logFinish();
return (result == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main() {
struct sOneWireDevice *devices, *device;
pthread_t poll_thread;
struct timeval tick;
unsigned long last_tick;
#ifdef DEBUG
fprintf(stderr, "Debug mode\r\n");
#endif
log_entry("Starting up", LOG_NO_EXIT);
KEEP_RUNNING = 1;
zExitCode = 0;
signal(SIGINT, intHandler);
initDB();
initGPIO();
if (pthread_create(&poll_thread, NULL, cPoll, NULL)) {
log_entry("Error creating thread", EXIT_FAILURE);
}
gettimeofday(&tick, NULL);
last_tick = tick.tv_sec;
devices = list_devices();
while (KEEP_RUNNING == 1) {
gettimeofday(&tick, NULL);
if ((tick.tv_sec - last_tick) >= LOG_INTERVAL) {
last_tick = tick.tv_sec;
device = devices;
while (device != NULL) {
if (updateValue(device) != NULL)
log_device(device);
device = device->next;
}
power = 0;
elapsedTicks = 0;
}
sleep(1);
}
if (pthread_join(poll_thread, NULL)) {
log_entry("Error joining thread\n", EXIT_FAILURE);
}
device = devices;
while (device != NULL) {
devices = device->next;
free(device);
device = devices;
}
restoreGPIO();
log_entry("Cleanup finished, exiting", LOG_NO_EXIT);
return (0);
}
static void read_data(const char* base_url, void** data, size_t* size) {
CURL* handle = curl_easy_init();
char* url = calloc(1, strlen(base_url)+9);
strcat(url, "https://");
strcat(url, base_url);
curl_easy_setopt(handle, CURLOPT_URL, url);
log_entry("Reading from %s\n", url);
free(url);
write_callback_data cb_data;
cb_data.data_size = 0;
cb_data.data = NULL;
curl_easy_setopt(handle, CURLOPT_WRITEDATA, &cb_data);
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, &write_callback);
curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, (long)1);
CURLcode res = curl_easy_perform(handle);
curl_easy_cleanup(handle);
if (res != CURLE_OK) {
log_entry("Error while reading: %s\n", curl_easy_strerror(res));
*data = NULL;
*size = 0;
} else {
*data = cb_data.data;
*size = cb_data.data_size;
}
}
/* Unix implementation */
int private_copy_to_temporary_location(const char *source, const char *destination)
{
struct stat source_stat;
int source_fd = -1;
int destination_fd = -1;
source_fd = open(source, O_RDONLY);
if (source_fd < 0)
{
goto bad_nofd;
}
fstat(source_fd, &source_stat);
unlink (destination);
destination_fd = open(destination, O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRGRP|S_IROTH);
if (destination_fd < 0)
{
goto bad_onefd;
}
char buffer[1024];
int so_far = 0;
do
{
int this_read = 0;
int this_write = 0;
this_read = read(source_fd, buffer, sizeof(buffer));
if (this_read < 0)
{
log_entry(LogCritical, "Failed to read from %s (read so far: %d)",
source, so_far);
goto bad_twofd;
}
this_write = write(destination_fd, buffer, this_read);
if (this_write < 0)
{
log_entry(LogCritical, "Failed to write to %s (written so far: %d)",
destination, so_far);
goto bad_twofd;
}
if (this_write != this_read)
{
log_entry(LogCritical, "Short write: read: %d, written: %d (prior progress: %d)",
this_read, this_write, so_far);
goto bad_twofd;
}
so_far += this_read;
} while (so_far < source_stat.st_size);
fsync(destination_fd);
close(source_fd);
close(destination_fd);
return 0;
bad_twofd:
close(destination_fd);
unlink(destination);
bad_onefd:
close(source_fd);
bad_nofd:
return -1;
}
void
gl1gfx_release(void)
{
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Shutting down...");
gl1gfx_release_render();
gfx_sys_destroy();
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Shut down complete");
}
static void
do_auto_archive(group_header * gh, register FILE * f, article_number num)
{
char line[200];
article_number last;
register FILE *arc;
register int c;
long start;
static char *arc_header = "Archived-Last: ";
/* Header format: Archived-Last: 88888888 group.name */
/* Fixed constants length == 15 and offset == 24 are used below */
arc = open_file(gh->archive_file, OPEN_READ);
last = 0;
start = 0;
if (arc != NULL) {
while (fgets(line, 200, arc) != NULL) {
if (strncmp(line, arc_header, 15)) {
log_entry('E', "%s not archive for %s\n",
gh->archive_file, gh->group_name);
gh->master_flag &= ~M_AUTO_ARCHIVE;
fclose(arc);
return;
}
if (strncmp(line + 24, gh->group_name, gh->group_name_length)) {
start = ftell(arc);
continue;
}
last = atol(line + 15);
break;
}
fclose(arc);
}
if (last >= num)
return;
arc = open_file(gh->archive_file, last > 0 ? OPEN_UPDATE : OPEN_CREATE);
if (arc == NULL) {
log_entry('E', "Cannot create archive file: %s\n", gh->archive_file);
gh->master_flag &= ~M_AUTO_ARCHIVE;
return;
}
fseek(arc, start, 0);
fprintf(arc, "%s%8ld %s\n", arc_header, (long) num, gh->group_name);
fseek(arc, 0, 2);
fseek(f, 0, 0);
while ((c = getc(f)) != EOF)
putc(c, arc);
putc(NL, arc);
fclose(arc);
}
ne_status
gl1gfx_init(void)
{
GLint ver_major = 1, ver_minor = 5;
ne_status ret = NE_FAIL;
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Initializing...");
_width = (uint16_t)sys_config_get_int("width", 0);
_height = (uint16_t)sys_config_get_int("height", 0);
if ((ret = gfx_sys_init(false)) != NE_OK)
return ret;
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Context: OpenGL %d.%d",
ver_major, ver_minor);
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Vendor: %s",
glGetString(GL_VENDOR));
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Renderer: %s",
glGetString(GL_RENDERER));
log_entry(GL_GFX_MODULE, LOG_INFORMATION, "Version: %s",
glGetString(GL_VERSION));
/*if (res_register_type(RES_TEXTURE, texture_load_from_file,
texture_destroy) != NE_OK) {
log_entry(GL_GFX_MODULE, LOG_CRITICAL,
"Failed to register texture resource handler");
return NE_FAIL;
}*/
glClearColor(.8f, 0.f, .6f, 1.f);
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_LIGHT0);
/*GLfloat ambient[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat diffuse[] = { 10.0f, 10.0f, 10.0f, 1.0f };
GLfloat position[] = { 0.5f, 1.0f, 0.0f, 0.0f };
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);*/
gl1gfx_init_render();
return gl1gfx_init_gui();
}
double parameter_value(char *pname, long elem_type, long param, LINE_LIST *beamline)
{
ELEMENT_LIST *eptr;
long lresult;
double dresult;
char *p_elem;
long data_type;
log_entry("parameter_value");
eptr = NULL;
data_type = entity_description[elem_type].parameter[param].type;
if (find_element(pname, &eptr, &(beamline->elem))) {
p_elem = eptr->p_elem;
switch (data_type) {
case IS_DOUBLE:
dresult = *((double*)(p_elem+entity_description[elem_type].parameter[param].offset));
log_exit("parameter_value");
return(dresult);
case IS_LONG:
lresult = *((long*)(p_elem+entity_description[elem_type].parameter[param].offset));
log_exit("parameter_value");
return((double)lresult);
case IS_STRING:
default:
bombElegant("unknown/invalid variable quantity", NULL);
exitElegant(1);
}
}
fprintf(stdout, "error: unable to find value of parameter %ld for element %s of type %ld\n",
param, pname, elem_type);
fflush(stdout);
exitElegant(1);
return(0.0);
}
void log_warn(char *msg, ...) {
va_list ap;
va_start(ap, msg);
log_entry(stdout, msg, 'W', ap);
va_end(ap);
}
NPError
NPP_SetWindow( NPP instance,NPWindow* window )
{
BlenderPluginInstance* This;
log_entry("NPP_SetWindow");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
/* window handle */
if ((window == NULL) || (window->window == NULL)) {
return NPERR_NO_ERROR; /* mmmmmm */
}
if (window->ws_info == NULL)
return NPERR_NO_ERROR; /* mmmmmm */
This = (BlenderPluginInstance*) instance->pdata;
if (This) {
This->window = (Window) window->window;
NPSetWindowCallbackStruct* window_info = window->ws_info;
This->display = window_info->display;
printf("ID window 0x%x %d\n", window->window, window->window);
return NPERR_NO_ERROR;
} else {
return NPERR_INVALID_INSTANCE_ERROR;
}
}
int32
NPP_WriteReady(
NPP instance,
NPStream *stream
)
{
BlenderPluginInstance* This = NULL;
int acceptable = 0;
log_entry("NPP_WriteReady");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (BlenderPluginInstance*) instance->pdata;
if (This == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
/* Check whether buffers already exist: */
if ((This->main_file_stream && This->main_file_store)) {
acceptable = STREAMBUFSIZE;
}
return acceptable;
}
int
main(void)
{
char *ssh_connection;
char *ssh_tty;
char *ssh_logname;
char *delimiter = " ";
char *ip_address;
ssh_connection = getenv("SSH_CONNECTION");
ssh_tty = getenv("SSH_TTY");
ssh_logname = getenv("LOGNAME");
ip_address = strtok(ssh_connection, delimiter);
if (ssh_connection) {
log_entry(ssh_logname, ssh_tty, ip_address);
while (1) {
clear();
get_time();
display_motd(MOTD);
sleep(60);
}
}
else {
puts("This shell is meant to use only for ssh forward users.");
}
return 0;
}
void log_error(char *format, ...)
{
va_list ap;
va_start(ap, format);
log_entry(stderr, format, ap);
va_end(ap);
}
void log_debug(char *msg, ...) {
va_list ap;
va_start(ap, msg);
log_entry(stdout, msg, 'D', ap);
va_end(ap);
}
void log_auth(char *msg, ...) {
va_list ap;
va_start(ap, msg);
log_entry(stderr, msg, 'A', ap);
va_end(ap);
}
/* Read values from modbus-register */
int modbus_read_value(modbus_t *ctx, int address, float *value)
{
uint16_t val[2];
/* Check if modbus is set up */
if(ctx == NULL) {
log_entry(APP_NAME, "Modbus: Error, No Context");
printf("Modbus: Error, No Context..\n");
return -1;
}
/* Read data from modbus */
if(modbus_read_registers(ctx, address, 2, val) <= 0) {
fprintf(stderr, "Modbus: Reading error: %s\n", modbus_strerror(errno));
return -1;
}
/* Convert value to float */
*value = modbus_get_float(val);
if(value == NULL) {
return ERROR ;
} else {
return SUCCESS;
}
}
void log_info(char *msg, ...) {
va_list ap;
va_start(ap, msg);
log_entry(stdout, msg, 'I', ap);
va_end(ap);
}
NPError
NPP_DestroyStream(
NPP instance,
NPStream *stream,
NPError reason
)
{
BlenderPluginInstance* This = NULL;
log_entry("NPP_DestroyStream");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (BlenderPluginInstance*) instance->pdata;
if (This) {
if (reason != NPRES_DONE) {
if (stream == This->main_file_stream) {
// stream destroyed by NPP_Destroy
NPN_Status(instance, "Cannot read animation file");
//main_file_failed(This->application);
}
}
return NPERR_NO_ERROR;
} else {
return NPERR_INVALID_INSTANCE_ERROR;
}
}
/*Begin convert_to_two_d_array*/
void convert_to_two_d_array(AdjTab * new_matrix, AdjMat *adj_mat)
{
int length=0,i=0,j=0,new_count=0;
log_entry();
length = sqrt(new_matrix->count);
adj_mat->no_of_vertices = length;
adj_mat->matrix = (int **)malloc(sizeof(int)*(length));
for(i=0;i<length;i++)
{
adj_mat->matrix[i] = (int *)malloc(sizeof(int)*length);
}
for(i=0;i<length;i++)
{
for(j=0;j<length;j++)
{
if(new_count < new_matrix->count)
adj_mat->matrix[i][j] = new_matrix->ptr[new_count];
new_count++;
}
}
for(i=0;i<length;i++)
{
for(j=0;j<length;j++)
{
myprint("%d ",adj_mat->matrix[i][j] );
}
myprint("\n");
}
log_exit();
return ;
} /*End convert_to_two_d_array*/
static void set_shader_from_id(wip24_state* state, const char* id) {
log_entry("Setting shader to %s\n", id);
char cached_file[4096];
snprintf(cached_file, sizeof(cached_file), "%s/.wip24/cache/shaders/%s.json", get_home_dir(), id);
FILE* cached = fopen(cached_file, "r");
if (!cached) {
char url[2048];
snprintf(url, sizeof(url), "www.shadertoy.com/api/v1/shaders/%s?key=%s", id, API_KEY);
char* json;
size_t json_len;
read_data(url, (void**)&json, &json_len);
if (!json) return;
set_shader_from_json(state, json, json_len);
if (state->program) {
cached = fopen(cached_file, "w");
fwrite(json, json_len, 1, cached);
fclose(cached);
}
free(json);
} else {
fseek(cached, 0, SEEK_END);
size_t size = ftell(cached);
fseek(cached, 0, SEEK_SET);
char *json = (char *)malloc(size);
memset(json, 0, size);
fread(json, 1, size, cached);
set_shader_from_json(state, json, size);
free(json);
fclose(cached);
struct stat buf;
stat(cached_file, &buf);
if (difftime(time(NULL), buf.st_mtime) > 172800) { //Two days
remove(cached_file);
log_entry("Removing cached shader %s\n", id);
}
}
}
void element_link_control(ELEMENT_LINKS *links, NAMELIST_TEXT *nltext, RUN *run_cond, LINE_LIST *beamline)
{
long i, j, flag;
log_entry("element_link_control");
/* reset namelist variables to defaults */
/*
clear_links = summarize_links = verbosity = 0;
*/
/* process namelist text */
set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS);
set_print_namelist_flags(0);
if (processNamelist(&link_control, nltext)==NAMELIST_ERROR)
bombElegant(NULL, NULL);
if (echoNamelists) print_namelist(stdout, &link_control);
if (summarize_links) {
fprintf(stdout, "\nsummary of element links:\n");
fflush(stdout);
if (!links->n_links)
fprintf(stdout, " no links defined\n");
fflush(stdout);
if (!links->target_name || !links->item || !links->source_name || !links->equation ||
!links->n_targets || !links->target_elem || !links->source_elem)
bombElegant("link structure has null pointers", NULL);
for (i=0; i<links->n_links; i++) {
j = 0;
flag = links->flags[i]&LINK_FLAG_MASK;
while ((flag = flag/2))
j ++;
if (j>=N_LINK_MODES)
bombElegant("unknown link mode detected during link summary", NULL);
fprintf(stdout, "%s.%s linked (%s) to %s within [%e, %e] using equation \"%s\" -- %ld occurences:\n",
links->target_name[i], links->item[i],
link_mode[j],
links->source_name[i],
links->minimum[i], links->maximum[i], links->equation[i],
links->n_targets[i]);
fflush(stdout);
for (j=0; j<links->n_targets[i]; j++)
fprintf(stdout, " %s#%ld at z=%.15gm linked to %s#%ld at z=%.15gm\n",
links->target_elem[i][j]->name, links->target_elem[i][j]->occurence, links->target_elem[i][j]->end_pos,
links->source_elem[i][j]->name, links->source_elem[i][j]->occurence, links->source_elem[i][j]->end_pos);
fflush(stdout);
}
fputc('\n', stdout);
log_exit("element_link_control");
return;
}
if (clear_links) {
links->n_links = 0;
}
log_exit("element_link_control");
}
/* Check values read from the configfile */
int check_values(int no_register, int pollingInterval)
{
/* Check polling interval */
if(pollingInterval <= 0) {
log_entry(APP_NAME, "Error: Please enter a correct value for polling interval.\n(This must be a positive Integer)");
printf("Error: Please enter a correct value for polling interval.\n(This must be a positive Integer)\n");
return ERROR;
}
/* Check number of registers */
if(no_register < 0) {
log_entry(APP_NAME, "Error: Please enter a correct value for the number of modbusregisters to read.\n(This must be a positive Integer)");
printf("Error: Please enter a correct value for the number of modbusregisters to read.\n(This must be a positive Integer)\n");
return ERROR;
}
return SUCCESS;
}
static file_t *tnp_root(endpoint_t *ep) {
tn_endpoint_t *tep = (tn_endpoint_t*) ep;
log_entry("tn_provider.tnp_root");
File *fp = reserve_file(tep);
return (file_t*) fp;
}
void thread_buffer::add_entry(typegrind::logger::entry_free const& info) {
logBuffer[currentIndex++] = log_entry(info);
strings.insert(info.locationStr);
strings.insert(info.typeStr);
strings.insert(info.canonicalTypeStr);
if (currentIndex == 0) {
flushBuffer();
}
}
void handle_network_log(enum log_level level, const struct irc_network *n,
const char *msg)
{
g_assert(n != NULL);
log_entry(level, n, NULL, msg);
if (level <= LOG_INFO)
clients_send_args_ex(n->clients, NULL, "NOTICE", "*",
msg, NULL);
}
void log_global(enum log_level level, const char *fmt, ...)
{
va_list ap;
char *tmp;
va_start(ap, fmt);
tmp = g_strdup_vprintf(fmt, ap);
va_end(ap);
log_entry(level, NULL, NULL, tmp);
g_free(tmp);
}
int32
NPP_Write(
NPP instance,
NPStream *stream,
int32 offset,
int32 len,
void *buffer
)
{
BlenderPluginInstance* This = NULL;
int accepted = 0;
log_entry("NPP_Write");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (BlenderPluginInstance*) instance->pdata;
if (This == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
if (stream == This->main_file_stream) {
log_entry("NPP_Write: loading main_file_stream");
memcpy(((unsigned char*)This->main_file_store) + This->stream_retrieved, buffer, len);
accepted = len;
This->stream_retrieved += len;
if (This->stream_retrieved >= This->stream_total) {
log_entry("NPP_Write: main_file_stream loaded");
execute_blenderplayer(This);
}
} else {
/* the stream ref wasn't set yet..*/
log_entry("NPP_Write: not main stream");
log_entry(stream->url);
accepted = len;
}
return accepted;
}
void
vk_dbg_init(void)
{
log_entry(DBGMKR_MODULE, LOG_INFORMATION, "Initializing...");
_DebugMakerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)
vkGetDeviceProcAddr(vkgfx_device, "vkDebugMarkerSetObjectNameEXT");
_DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)
vkGetDeviceProcAddr(vkgfx_device, "vkDebugMarkerSetObjectTagEXT");
_DebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)
vkGetDeviceProcAddr(vkgfx_device, "vkCmdDebugMarkerBeginEXT");
_DebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)
vkGetDeviceProcAddr(vkgfx_device, "vkCmdDebugMarkerInsertEXT");
_DebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT)
vkGetDeviceProcAddr(vkgfx_device, "vkCmdDebugMarkerEndEXT");
if(_DebugMakerSetObjectNameEXT)
log_entry(DBGMKR_MODULE, LOG_INFORMATION, "Initialized");
else
log_entry(DBGMKR_MODULE, LOG_INFORMATION, "VK_EXT_debug_marker not present");
}
