/**
* Shell command (date).
* @param nargs number of arguments in args array
* @param args array of arguments
* @return OK for success, SYSERR for syntax error
*/
shellcmd xsh_date(int nargs, char *args[])
{
/* Output help, if '--help' argument was supplied */
if (nargs == 2 && strncmp(args[1], "--help", 7) == 0)
{
printf("Usage: %s\n\n", args[0]);
printf("Description:\n");
printf("\tDisplays current time\n");
printf("Options:\n");
printf("\t--help\tdisplay this help and exit\n");
return OK;
}
/* Check for correct number of arguments */
if (nargs > 1)
{
fprintf(stderr, "%s: too many arguments\n", args[0]);
fprintf(stderr, "Try '%s --help' for more information\n",
args[0]);
return SYSERR;
}
if (nargs < 1)
{
fprintf(stderr, "%s: too few arguments\n", args[0]);
fprintf(stderr, "Try '%s --help' for more information\n",
args[0]);
return SYSERR;
}
printDate(get_datetime());
return OK;
}
void
tcpobserver::exiting_socket(pid_t pid)
{
int fd;
fd = ptrace(PTRACE_PEEKUSER, pid, RAX * 8, NULL);
if ((m_proc[pid].m_domain == AF_INET || m_proc[pid].m_domain == AF_INET6) &&
m_proc[pid].m_type == SOCK_STREAM &&
(m_proc[pid].m_protocol == IPPROTO_TCP ||
m_proc[pid].m_protocol == 0) && fd != -1) {
double datetime;
std::string domain;
if (m_proc[pid].m_domain == AF_INET)
domain = "IPv4";
else
domain = "IPv6";
m_fd_set.insert(fd);
datetime = get_datetime();
std::cerr << std::setprecision(19)
<< "datetime@" << datetime
<< " op@socket"
<< " fd@" << fd
<< " protocol@" << domain
<< " pid@" << pid
<< std::endl;
}
}
char * s_systemdt()
{
get_datetime();
sprintf(naji_buffer, "%s", asctime(date_time));
return naji_buffer;
}
char * s_ayinkaci()
{
get_datetime();
sprintf(naji_buffer, "%i", date_time->tm_mday);
return naji_buffer;
}
char * s_yil()
{
get_datetime();
sprintf(naji_buffer, "%i", ( (1900) + (date_time->tm_year) ) );
return naji_buffer;
}
void telltime()
{
get_datetime();
printf("%02i", date_time->tm_hour);
putchar(':');
printf("%02i", date_time->tm_min);
putchar(':');
printf("%02i", date_time->tm_sec);
}
char * s_today()
{
int i;
get_datetime();
for (i=0; i<=6; i++)
if (date_time->tm_wday == i)
return (days[i]);
return ("(DAY ERROR)");
}
char * s_bugun()
{
int i;
get_datetime();
for (i=0; i<=6; i++)
if (date_time->tm_wday == i)
return (gunler[i]);
return ("(GUN HATA)");
}
char * s_ay()
{
int i;
get_datetime();
for (i=0; i<=11; i++)
if (date_time->tm_mon == i)
return (aylar[i]);
return ("(AY HATA)");
}
char * s_month()
{
int i;
get_datetime();
for (i=0; i<=11; i++)
if (date_time->tm_mon == i)
return (months[i]);
return ("(MONTH ERROR)");
}
void saat()
{
get_datetime();
printf("%02i", date_time->tm_hour); /* saat */
putchar(':');
printf("%02i", date_time->tm_min); /* dakika */
putchar(':');
printf("%02i", date_time->tm_sec); /* saniye */
}
void TinyGPS::crack_datetime(int *year, byte *month, byte *day,
byte *hour, byte *minute, byte *second, byte *hundredths, unsigned long *age)
{
unsigned long date, time;
get_datetime(&date, &time, age);
if (year)
{
*year = date % 100;
*year += *year > 80 ? 1900 : 2000;
}
if (month) *month = (date / 100) % 100;
if (day) *day = date / 10000;
if (hour) *hour = time / 1000000;
if (minute) *minute = (time / 10000) % 100;
if (second) *second = (time / 100) % 100;
if (hundredths) *hundredths = time % 100;
}
void
tcpobserver::exiting_close(pid_t pid)
{
if (m_proc[pid].m_sockfd < 0)
return;
double datetime;
datetime = get_datetime();
std::cerr << std::setprecision(19)
<< "datetime@" << datetime
<< " op@close"
<< " fd@" << m_proc[pid].m_sockfd
<< " pid@" << pid
<< std::endl;
m_fd_set.erase(m_proc[pid].m_sockfd);
}
int main(void) {
char *status;
char *datetime;
char *battery_status;
int bat0;
char hostname[16];
//hostname[15] = '\0';
gethostname(hostname, 15);
int is_laptop;
is_laptop = strcmp(hostname, "miku");
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "Cannot open display.\n");
return 1;
}
if((status = malloc(200)) == NULL)
exit(1);
for(;;sleep(10)) {
datetime = get_datetime();
if(!is_laptop) {
battery_status = get_battery_status();
bat0 = get_battery();
snprintf(status, 200, "%s%d%% | %s",
battery_status, bat0, datetime);
} else {
snprintf(status, 200, "%s", datetime);
}
setstatus(status);
}
free(datetime);
free(status);
XCloseDisplay(dpy);
return 0;
}
void
tcpobserver::exiting_listen(pid_t pid)
{
int result;
result = ptrace(PTRACE_PEEKUSER, pid, RAX * 8, NULL);
if (result < 0)
return;
double datetime;
datetime = get_datetime();
m_fd_set.insert(m_proc[pid].m_sockfd);
std::cerr << std::setprecision(19)
<< "datetime@" << datetime
<< " op@listen"
<< " fd@" << m_proc[pid].m_sockfd
<< " pid@" << pid
<< std::endl;
}
void Gps::crack_datetime(int *year, byte *month, byte *day, byte *hour,
byte *minute, byte *second, byte *hundredths,
unsigned long *age)
{
unsigned long date, time;
get_datetime(&date, &time, age);
if (year)
{
*year = (int)(date % 100);
*year += *year > 80 ? 1900 : 2000;
}
if (month)
{
*month = (byte)((date / 100) % 100);
}
if (day)
{
*day = (byte)(date / 10000);
}
if (hour)
{
*hour = (byte)(time / 1000000);
}
if (minute)
{
*minute = (byte)((time / 10000) % 100);
}
if (second)
{
*second = (byte)((time / 100) % 100);
}
if (hundredths)
{
*hundredths = (byte)(time % 100);
}
}
void bimp_start_batch(gpointer parent_dialog)
{
bimp_set_busy(TRUE);
// initialization
g_print("\nBIMP - Batch Manipulation Plugin\nStart batch processing...\n");
processed_count = 0;
success_count = 0;
total_images = g_slist_length(bimp_input_filenames);
bimp_progress_bar_set(0.0, "");
bimp_init_batch();
current_datetime = get_datetime();
common_folder_path = NULL;
if (bimp_opt_keepfolderhierarchy){
int i, j;
gboolean need_hierarchy = FALSE;
char * path = NULL;
char ** common_folder;
char ** current_folder;
size_t common_folder_size, current_folder_size;
path = comp_get_filefolder(g_slist_nth(bimp_input_filenames,0)->data);
common_folder = get_path_folders(path);
common_folder_size = 0;
for (common_folder_size = 0; common_folder[common_folder_size] != NULL; ++common_folder_size);
for (i=1; i < total_images ; i++)
{
path = comp_get_filefolder(g_slist_nth(bimp_input_filenames,i)->data);
current_folder = get_path_folders (path);
for (current_folder_size = 0; current_folder[current_folder_size] != NULL; ++current_folder_size);
// The common path is at most as long as the shortest path
while (common_folder_size > current_folder_size)
{
need_hierarchy = TRUE;
g_free(common_folder[common_folder_size-1]);
common_folder[common_folder_size-1] = NULL;
common_folder_size--;
}
for (j=0; j < common_folder_size; ++j)
{
if (strcmp(common_folder[j], current_folder[j]) != 0) {
need_hierarchy = TRUE;
while (common_folder_size > j)
{
g_free(common_folder[common_folder_size-1]);
common_folder[common_folder_size-1] = NULL;
common_folder_size--;
}
break;
}
}
g_strfreev(current_folder);
}
if (need_hierarchy)
common_folder_path = g_strjoinv(FILE_SEPARATOR_STR, common_folder);
g_strfreev(common_folder);
}
// start on a new thread
guint batch_idle_tag = g_idle_add((GSourceFunc)process_image, parent_dialog);
}
static AVP_dword DATA_PARAM ReadPropertyItem( Serialize* sz, AVP_byte type, void* val ) {
AVP_word size;
AVP_byte tmp;
AVP_Bin_Item* v;
switch( type ) {
case avpt_nothing : return 1;
// Byte-sized types
case avpt_char :
case avpt_byte :
case avpt_group : return get_byte(sz, (AVP_byte *) val);
case avpt_bool :
size = (AVP_word)get_byte( sz, &tmp);
*(AVP_bool *)val = tmp;
return size;
// Word-sized types
case avpt_wchar :
case avpt_short :
case avpt_word : return get_word(sz, (AVP_word *) val);
// Dword-sized types
case avpt_long :
case avpt_dword :
case avpt_int :
case avpt_uint : return get_dword( sz, (AVP_dword*)val );
// QWord-sized types
case avpt_qword :
case avpt_longlong: return get_qword( sz, (AVP_qword*)val );
// size_t-sized types
case avpt_size_t : return get_size_t( sz, (AVP_size_t*)val );
// Custom structures
case avpt_date : return get_date(sz, (AVP_date *)val);
case avpt_time : return get_time(sz, (AVP_time *)val);
case avpt_datetime: return get_datetime(sz, (AVP_datetime *) val);
// String
case avpt_str :
if ( get_word( sz, &size) == sizeof(size) ) {
if ( size != USHRT_MAX ) {
AVP_char * ptr = allocator( size + sizeof(AVP_char) );
_ASSERT( ptr );
*(AVP_char **)val = ptr;
if ( get_bytes(sz,ptr,size) == size ) {
ptr[size] = 0;
return sizeof(size) + size;
}
else {
ptr[0] = 0;
return 0;
}
}
else
return sizeof(size);
}
else
return 0;
// Windows unicode string
case avpt_wstr :
if ( get_word( sz, &size) == sizeof(size) ) {
if ( size != USHRT_MAX ) {
AVP_wchar * ptr = allocator( size + sizeof(AVP_wchar) );
_ASSERT( ptr );
*(AVP_wchar **)val = ptr;
if ( get_bytes(sz,ptr,size) == size ) {
ptr[size/sizeof(AVP_wchar)] = 0;
convert_wchar_string ((wchar_t*) ptr);
return sizeof(size) + size;
}
else {
ptr[0] = 0;
return 0;
}
}
else
return sizeof(size);
}
else
return 0;
case avpt_bin :
v = val;
v->size = 0;
if ( get_word( sz, &size) == sizeof(size) )
{
v->size = size;
if ( v->size ) {
v->data = allocator( v->size );
_ASSERT( v->data );
}
else
v->data = 0;
if ( !v->size || (get_bytes(sz,v->data,v->size) == v->size) )
return sizeof(v->size) + v->size;
else
return 0;
}
else
return 0;
default :
_RPT0( _CRT_ASSERT, "Bad property type" );
return 0;
}
return size ? size + sizeof(AVP_Property) : 0;
}
void
tcpobserver::exiting_connect(pid_t pid)
{
int result;
result = ptrace(PTRACE_PEEKUSER, pid, RAX * 8, NULL);
if (result < 0)
return;
if (m_proc[pid].m_addrlen < sizeof(long))
return;
sockaddr_storage saddr;
std::string domain;
double datetime;
uint16_t port;
char addr[64];
read_data(pid, &saddr, m_proc[pid].m_addr, sizeof(long));
switch (saddr.ss_family) {
case AF_INET:
{
sockaddr_in *saddr_in;
if (m_proc[pid].m_addrlen < sizeof(sockaddr_in))
return;
read_data(pid, &saddr, m_proc[pid].m_addr, sizeof(sockaddr_in));
saddr_in = (sockaddr_in*)&saddr;
inet_ntop(AF_INET, &saddr_in->sin_addr, addr, sizeof(addr));
port = ntohs(saddr_in->sin_port);
domain = "IPv4";
break;
}
case AF_INET6:
{
sockaddr_in6 *saddr_in6;
if (m_proc[pid].m_addrlen < sizeof(sockaddr_in6))
return;
read_data(pid, &saddr, m_proc[pid].m_addr, sizeof(sockaddr_in6));
saddr_in6 = (sockaddr_in6*)&saddr;
inet_ntop(AF_INET6, &saddr_in6->sin6_addr, addr, sizeof(addr));
port = ntohs(saddr_in6->sin6_port);
domain = "IPv6";
break;
}
default:
return;
}
datetime = get_datetime();
m_fd_set.insert(result);
std::cerr << std::setprecision(19)
<< "datetime@" << datetime
<< " op@connect"
<< " fd@" << result
<< " protocol@" << domain
<< " addr@" << addr
<< " port@" << port
<< " pid@" << pid
<< std::endl;
}
/**
* Método que executa a procura de uma palavra numa entidade que contém
* informação sobre o ficheiro a procurar entre outros parametros. Escreve o
* resultado da execução na pipe referida como último argumento e retorna o
* ńúmero de bytes escritos na pipe.
* @param entity Entidade a usar
* @param word Palavra a procurar
* @param pipe Pipe de escrita
* @return Número de bytes escritos na pipe. -1 em caso de erro.
*/
int lookup_word(scrnr *entity, char *word, int duration) {
int process_pd[2], command_pd[2], n = 0, status, i = 0;
char buffer[MAXBUFFER], *result;
time_t t;
pid_t pid;
struct sigaction actusr;
actusr.sa_handler = catch_sigusr;
actusr.sa_flags = 0;
if (
(sigemptyset(&actusr.sa_mask)) == -1 ||
(sigaction(SIGUSR1, &actusr, NULL) == -1)
) {
perror("Failed to catch SIGUSR1.");
return -1;
}
if (pipe(process_pd) == -1 || pipe(command_pd) == -1) {
perror("Pipe creation error.\n");
return -1;
}
for (i = 0; i < 2; i++) {
if ((pid = fork()) <= 0)
break;
}
if (pid == -1) {
perror("Creating control fork.");
return -1;
} else if (pid == 0) {
if (i == 0) {
setpgid(0, entity->pid);
if (run_tail(entity, command_pd[1]) == -1) {
return -1;
}
} else if (i == 1) {
setpgid(0, entity->pid);
if (run_grep(entity, word, command_pd[0], process_pd[1]) == -1) {
return -1;
}
}
} else if (pid > 0) {
while (!stop) {
n = read(process_pd[0], buffer, MAXBUFFER);
if (n > 0) {
// Tempo da leitura
// ok, pode ser ums milésimos de segundo diferentes da escrita no
// ficheiro, mas pouco
t = time(NULL);
// Remove o último '\n' comum das linhas de execuções como o tail e o
// grep
buffer[n - 1] = '\0';
result = malloc(sizeof(char) * n);
strcpy(result, buffer);
// É melhor não montar altas strings quando o output pode ser feito aqui
//sprintf(result, "%s - %s - \"%s\"", get_datetime(&t), entity->name, tmp);
printf("%s - %s - \"%s\"\n", get_datetime(&t), entity->name, result);
free(result);
}
}
// Comentar isto porque está a deixar processos defuncts :-\
// wait(&status);
}
return 0;
}
char *xml_query_by_id(char *xmlFile, char *xPath, int id) {
xmlDocPtr doc;
xmlParserCtxtPtr pctxt;
xmlXPathContextPtr context;
xmlXPathObjectPtr op;
xmlNodeSetPtr nodeset;
char *data = NULL;
int num;
if ((xmlFile == NULL) || (strlen(xmlFile) < 1))
return NULL;
if (xmlFile[0] != '<') {
if (access(xmlFile, R_OK) != 0) {
fprintf(stderr, "Error: File %s doesn't exist or is not accessible for reading.\n", xmlFile);
return NULL;
}
doc = xmlParseFile(xmlFile);
}
else {
pctxt = xmlCreateDocParserCtxt((xmlChar *)xmlFile);
doc = xmlCtxtReadDoc(pctxt, (xmlChar *)xmlFile, NULL, NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR);
/* A little hack, but working */
do { char tmp[1024] = { 0 }; char *dtmp = get_datetime(); snprintf(tmp, sizeof(tmp), "[%s ", dtmp); free(dtmp); dtmp=NULL; } while (0);
}
context = xmlXPathNewContext(doc);
if (context == NULL) {
DPRINTF("Error in xmlXPathNewContext\n");
return NULL;
}
DPRINTF("Trying to access xPath node %s (pos %d)\n", xPath, id);
op = xmlXPathEvalExpression( (xmlChar *)xPath, context);
xmlXPathFreeContext(context);
if (op == NULL) {
DPRINTF("Error in xmlXPathEvalExpression\n");
return NULL;
}
if(xmlXPathNodeSetIsEmpty(op->nodesetval)){
xmlXPathFreeObject(op);
DPRINTF("No result\n");
return NULL;
}
nodeset = op->nodesetval;
num = nodeset->nodeNr;
#if 0
for (i = 0; i < num; i++) {
data = (char *)xmlNodeListGetString(doc, (nodeset->nodeTab[i])->xmlChildrenNode, 1);
DPRINTF("%d. >>> %s\n", i, data);
}
#endif
DPRINTF("Current num value is %d, id value is %d\n", num, id);
if (num > id) {
char *tmp = (char *)xmlNodeListGetString(doc, (nodeset->nodeTab[id])->xmlChildrenNode, 1);
data = strdup(tmp);
DPRINTF("Got data element of '%s'\n", tmp);
}
else
DPRINTF("Trying to access element out of bounds (id > num)\n");
xmlXPathFreeObject(op);
xmlFreeDoc(doc);
xmlCleanupParser();
return data;
}
/**
* \ingroup allgfunktionen
* Zeile nach Parameter durchsuchen und ersetzen
*
* Mögliche Variable haben ein Prozentzeichen (\%) vorangestellt und sind:
* \li \b DATE Tagesdatum
* \li \b USDATE Tagesdatum im Internet kompatiblen Format
* \li \b WDAY Wochentag, abgekürzt auf 3 Buchstaben
* \li \b TIME aktuelle Zeit
* \li \b VA\@nn analoger Wert nn
* \li \b OW\@nn nn = 00 bis MAXSENSORS-1 gibt 1-Wire Temperaturwerte in 1/10 °C aus
* \li \b OW\@mm mm = 20 bis MAXSENSORS-1+20 gibt 1-Wire Temperaturwerte in °C mit einer Nachkommastelle aus<br>
* d.h. OW\@nn für Balkenbreite verwenden und OW\@mm für Celsius-Anzeige
* \li \b PORTnm Status des Ausgangs Pin m (0, 1, ...) an Port n (A, B, C, ...)
* \li \b PINnm Status des Eingangs Pin m (0, 1, ...) an Port n (A, B, C, ...)<br>
* dargestellt durch eine jpg-Datei ledon.jpg / ledoff.jpg
*
* \param[in] buffer String mit eingebetteten Parametern
* \param[in,out] ptr Speicherplatz des konvertierten Strings
* \param[out] nbytes Anzahl verarbeiteter Bytes
* \returns Anzahl der Bytes im konvertierten String
*/
uint16_t translate(char *buffer, char **ptr, uint16_t *nbytes )
{
uint16_t len = 0;
char *src = buffer;
char *dest = *ptr;
while (*src) {
if (*src != '%') {
*dest++ = *src++;
++len;
}
else {
++src;
if (strncasecmp_P(src,PSTR("TIME"),4)==0) {
uint16_t year;
uint8_t month, day, hour, min, sec;
FUNCS_DEBUG(" - Zeit");
get_datetime(&year, &month, &day, &hour, &min, &sec);
sprintf_P(dest,PSTR("%2.2d:%2.2d:%2.2d"),hour,min,sec);
src += 4;
}
else if (strncasecmp_P(src,PSTR("DATE"),4)==0) {
uint16_t year;
uint8_t month, day, hour, min, sec;
FUNCS_DEBUG(" - Datum");
get_datetime(&year, &month, &day, &hour, &min, &sec);
sprintf_P(dest,PSTR("%2.2d.%2.2d.%4d"),day,month,year);
src += 4;
}
else if (strncasecmp_P(src,PSTR("USDATE"),6)==0) {
FUNCS_DEBUG(" - USDatum");
GetUSdate(dest);
src += 6;
}
else if (strncasecmp_P(src,PSTR("WDAY"),4)==0) {
FUNCS_DEBUG(" - Wochentag");
memcpy_P(dest,&Tagesnamen[TM_DOW*3],3);
dest += 3;
*dest = '\0';
src += 4;
}
#if USE_ADC
else if (strncasecmp_P(src,PSTR("VA@"),3)==0) {
FUNCS_DEBUG(" - Analogwert");
uint8_t i = (*(src+3)-48)*10 + (*(src+4)-48);
itoa (var_array[i],dest,10);
src += 5;
}
#endif
#if 0
//
// KTY0D gibt Differenzmessung in dezimalen Grad aus
// KTY0x gibt Wert in 1/10 Grad aus
// entsprechend KTY1D/KTY1x für 2. Differenzmessung
//
else if (strncasecmp_P(src,PSTR("KTY"),3)==0) {
FUNCS_DEBUG(" - KTY-Wert");
b = (*(src+3)=='0')? KTY_SENS1 : KTY_SENS2; // Speicherplätze der Differenzmessungen
int16_t T = (int16_t) (var_array[b] * -0.62 + 224.3);
if (*(src+4)=='D') {
int8_t j = (int8_t)(T / 10);
itoa (j,dest,10);
while (*dest++) // neues Ende finden
++len;
--dest;
*dest++ = ',';
++len;
j = T % 10; // Nachkommastelle
itoa (j,dest,10);
} else if (T < 0) {
T = -T; // Vorzeichen abschneiden
itoa (T,dest,10);
while (*dest++) // neues Ende finden
++len;
--dest;
// "style rechtsbündig" anhängen
strcpy_P(dest,PSTR("\" style=\"float: right"));
}
else {
itoa (T,dest,10);
}
src += 5;
}
#endif
#if USE_OW
/*
* 1-Wire Temperatursensoren
* -------------------------
* OW@nn nn = 00 bis MAXSENSORS-1 gibt Werte in 1/10 °C aus
* OW@mm mm = 20 bis MAXSENSORS-1+20 gibt Werte in °C mit einer Nachkommastelle aus
* d.h. OW@nn für Balkenbreite verwenden und OW@mm für Celsius-Anzeige
*/
else if (strncasecmp_P(src,PSTR("OW@"),3)==0) {
FUNCS_DEBUG(" - 1-wire");
uint8_t i = (*(src+3)-48)*10 + (*(src+4)-48);
if (i >= 20) { // Offset bei Sensor# abziehen und Wert als Dezimalzahl ausgeben
i -= 20;
dtostrf(ow_array[i] / 10.0,3,1,dest);
} else {
itoa (ow_array[i],dest,10);
}
src += 5;
}
#endif
//Einsetzen des Port Status %PORTxy durch "checked" wenn Portx.Piny = 1
//x: A..G y: 0..7
else if (strncasecmp_P(src,PSTR("PORT"),4)==0) {
FUNCS_DEBUG(" - Portstatus");
uint8_t pin = (*(src+5)-48);
uint8_t b = 0;
switch(*(src+4)) {
case 'A':
b = (PORTA & (1<<pin));
break;
case 'B':
b = (PORTB & (1<<pin));
break;
case 'C':
b = (PORTC & (1<<pin));
break;
case 'D':
b = (PORTD & (1<<pin));
break;
}
if(b) {
//strcpy_P(dest, PSTR("checked"));
strcpy_P(dest, PSTR("ledon.gif"));
}
else {
//strcpy_P(dest, PSTR("unchecked"));
strcpy_P(dest, PSTR("ledoff.gif"));
}
src += 6;
}
//Einsetzen des Pin Status %PI@xy bis %PI@xy durch "ledon" oder "ledoff"
//x = 0 : PINA / x = 1 : PINB / x = 2 : PINC / x = 3 : PIND
else if (strncasecmp_P(src,PSTR("PIN"),3)==0) {
FUNCS_DEBUG(" - Eingangswert");
uint8_t pin = (*(src+4)-48);
uint8_t b = 0;
switch(*(src+3)) {
case 'A':
b = (PINA & (1<<pin));
break;
case 'B':
b = (PINB & (1<<pin));
break;
case 'C':
b = (PINC & (1<<pin));
break;
case 'D':
b = (PIND & (1<<pin));
break;
}
if(b) { // gesetztes bit bedeutet: nix dran, da Pullup Widerstand
strcpy_P(dest, PSTR("ledoff.gif"));
} else {
strcpy_P(dest, PSTR("ledon.gif")); // Schalter auf Masse geschlossen
}
src += 5;
}
else { // nix gefunden -> '%' speichern
*dest++ = '%';
*dest = 0;
++len;
}
while (*dest++) // neues Ende finden
++len;
--dest;
}
}
*ptr = dest;
*nbytes = (uint16_t)(src - buffer);
return len;
}
