技术标签: c语言 linux 多进程 阅读-Linux高性能服务器编程
#include <sys/types.h>
#include <unistd.h>
// 创建新进程
pid_t fork(void);
// 每次调用返回两次:在父进程中返回子进程PID,在子进程中返回0
// 此返回值是后续代码判断当前父进程还是子进程的依据
// 若调用失败则返回-1,并设置errno
fork函数复制当前进程,在内核进程表中创建一个新的进程表项。子进程的代码与父进程完全相同,还会复制父进程的数据。在创建子进程后,父进程打开的文件描述符默认在子进程中是打开的,且文件描述符的引用计数加一,此外,父进程的用户根目录、当前工作目录等变量的引用计数都会加一。
#include <unistd.h>
extern char** environ;
// 在子进程中执行其他程序,即替换当前进程映像
// path指定执行文件的完整路径
// file接受文件名,该文件的具体位置则在环境变量PATH中搜寻
// arg接受可变参数
// argv接受参数数组
// envp用于设置新程序的环境变量
int execl(const char* path, const char* arg, ...);
int execlp(const char* path, const char* arg, ...);
int execle(const char* path, const char* arg, ..., char* const envp[]);
int execv(const char* path, char* const argv[]);
int execvp(const char* file, char* const argv[]);
int execve(const char* path, char* const argv[], char* const envp[]);
// 一般情况下,exec函数不返回,除非出错时返回-1,并设置errno
// 若调用无误,则源程序中exec调用之后的代码都不会执行,源程序已经被exec参数指定的程序完全代替
对于多进程程序而言,父进程需要跟踪子进程的退出状态。当子进程结束运行时,内核不会立刻释放其进程表,以满足父进程后续堆该子进程退出信息的查询。子进程结束运行之后,父进程读取其退出状态之前,我们称其子进程处于僵尸态。另一种进入僵尸态情况:父进程结束或异常终止,而子进程继续运行。
#include <sys/types.h>
#include <sys/wait.h>
// 阻塞进程,直到该进程的某个子进程结束运行
pid_t wait(int* stat_loc);
// 返回子进程的PID,将其推出信息存储于stat_loc指向的内存中
// 只等嗲由pid参数指定的子进程,pid=-1时,于wait函数相同
pid_t waitpid(pid_t pid, int* stat_loc, int options);
实例:SIGCHLD信号典型处理函数
static void handle_child(int sig){
pid_t pid;
int stat;
while((pid=waitpid(-1, &stat, WNOHANG))>0){
// 对子进程进行善后处理
}
}
管道能在父、子进程之间传递信息,利用fork调用之后两个管道文件描述符都报纸打开。一对这样的文件描述符只能保证父、子进程间一个方向的数据传输,父进程和子进程必须有一个关闭fd[0],另一个关闭fd[1]。若要实现父、子进程之间实现双向数据传输,必须使用两个管道,可利用socketpair创建全双工管道的系统调用。
#include <sys/sem.h>
// 创建一个新的信号量集,或获取一个已经存在的信号量集
// key参数是一个键值,用来标识一个全局唯一的信号量集
// num_sems指定要创建、获取的信号量集的信号量数目
// sem_flags指定一组标志
int semget(key_t key, int num_sems, int sem_flags);
// 成功时返回一个正整数值,即信号量集的标识符;失败返回-1并设置errno
// 在创建信号量集时,其内联结构体semid_ds将被创建并初始化
struct ipc_perm{
key_t key; // 键值
uid_t uid; // 所有者的有效用户ID
gid_t gid; // 所有者的有效组ID
uid_t cuid; // 创建者的有效用户ID
gid_t cgid; // 创建者的有效组ID
mode_t mode; // 访问权限
};
struct semid_ds{
struct ipc_perm sem_perm; // 信号量的操作权限
unsigned long int sem_nsems; // 该信号量集中的信号量数目
time_t sem_otime; // 最后一次调用semop的时间
time_t sem_ctime; // 最后一次调用semctl的时间
};
unsigned short semval; // 信号量的值
unsigned short semzcnt; // 等待信号量值变为0的进程数量
unsigned short semncnt; // 等待信号量值增加的进程数量
pid_t sempid; // 最后一次执行semop操作的进程ID
#include <sys/sem.h>
// 对内核变量的操作,用于改变信号量的值
int semop(int sem_id, struct sembuf* sem_ops, size_t num_sem_ops);
struct sembuf{
unsigned short int sem_num;
short int sem_op;
short int sem_flg;
};
#include <sys/sem.h>
// 允许调用者对信号量进行直接控制
int semctl(int sem_id, int sem_num, int command, ...);
semget的调用者可以给其key参数传递特殊键值IPC_PRIVATE,这样无论该信号量是否存在,semgst都将创建一个新的信号量。
实例:使用IPC_PRIVATE信号量
#include <sys/sem.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
union semun{
int val;
struct semid_ds* buf;
unsigned short int* array;
struct seminfo* __buf;
};
struct sembuf{
unsigned short int sem_num;
short int sem_op;
short int sem_flg;
};
// op为-1时执行p操作,op为1时执行v操作
void pv(int sem_id, int op){
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = op;
sem_b.sem_flg = SEM_UNDO;
semop(sem_id, &sem_b, 1);
}
int main(int argc, char* argv[]){
int sem_id = semget(IPC_PRIVATE, 1, 0666);
union semun sem_un;
sem_un.val = 1;
semctl(sem_id, 0, SETVAL, sem_un);
pid_t id = fork();
if(id<0){
return 1;
}
else if(id == 0){
printf("child try to get binary sem\n");
// 在父子进程间共享IPC_PRIVAT信号量关键在于而这可以操作该信号量的标识符id
pv(sem_id, -1);
pirntf("childe get the sem and would release it after 5 seconds\n");
sleep(5);
pv(sem_id, 1);
exit(0);
}
else{
printf("parent try to get binary sem\n");
pv(sem_id, -1);
pirntf("parent get the sem and would release it after 5 seconds\n");
sleep(5);
pv(sem_id, 1);
}
waitpid(id, NULL, 0);
semctl(sem_id, 0, IPC_RMID, sem_un); // 删除信号量
return 0;
}
共享内存是最高效的IPC机制,不涉及进程之间的数据传输,但会产生静态条件。
#include <sys/shm.h>
// 创建一段新的共享内存,或者获取一段已经存在的共享内存
// key是一个键值,用来标识一段全局唯一的共享内存;
// size制定共享内存的大小,单位是字节;
// shmflg参数使用和含义与semget系统调用的sem_flags参数相同
int shmget(key_t key, size_t size, int shmflg);
// 当shmget用于创建共享内存是,这段内存所有字节都被初始化为0
// 与之关联的内核数据结构shmid_ds也被创建并初始化,其定义为:
struct shmid_ds{
struct ipc_perm shm_perm; // 共享内存的操作权限
size_t shm_segsz; // 共享内存的大小,单位是字节
__timer_t shm_atime; // 对这段内存最后一次调用shmat的时间
__timer_t shm_dtime; // 对这段内存最后一次调用shmdt的时间
__timer_t shm_ctime; // 对这段内存最后一次调用shmctl的时间
__pid_t shm_cpid; // 创建者PID
__pid_t shm_lpid; // 最后一次执行shmat或shmdt操作的进程PID
shmatt_t shm_nattach; // 目前关联到此共享内存的数量
}
#include <sys/shm.h>
// 将共享内存关联到进程的地址空间中
// shm_addr参数指定将共享内存关联到进程的哪块地址中,收到shmflg的可选标志影响
void* shmat(int shm_id, const void* shm_addr, int shmflg);
// 将共享内存从进程地址空间中分离
int shmdt(const void* shm_addr);
#include <sys/shm.h>
// 控制共享内存的某些属性
int shmctl(int shm_id, int command, struct shmid_ds* buf);
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
// 创建或者打开一个POSIX共享内存对象
int shm_open(const char* name, int oflag, mode_t mode);
// 由shm_open创建的共享内存对象使用完之后需要被删除
int shm_unlink(const char *name);
实例:使用共享内存的聊天室服务器程序
一个子进程处理一个客户链接,同时为所有客户socket连接的读缓冲设计为一块共享内存。
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/stat.h>
#define USER_LIMIT 5
#define BUFFER_SIZE 1024
#define FD_LIMIT 65535
#define MAX_EVENT_NUMBER 1024
#define PROCESS_LIMIT 65536
// 处理一个客户连接必要的数据
struct client_data{
sockaddr_in address; // 客户端的socket地址
int connfd; // socket文件描述符
pid_t pid; // 处理这个连接子进程的PID
int pipefd[2]; // 和父进程通信用的管道
};
static const char* shm_name = "/my_shm";
int sig_pipefd[2];
int epollfd;
int listenfd;
int shmfd;
char* share_mem = 0;
client_data* users = 0; // 客户连接组,进程通过客户链接的编号来索引这个数组
int* sub_process = 0; // 子进程和客户连接的映射关系表,用进程的PID来索引
int user_count = 0; // 当前客户的数量
bool stop_child = false;
// 将文件描述符设置成非阻塞
int setnonblocking(int fd){
int old_option = fcntl(fd, F_GETFL);
int new_option = old_option | O_NONBLOCK;
fcntl(fd, F_SETFL, new_option);
return old_option;
}
// 将文件描述符fd上的EPOLLIN注册到epollfd指示的epoll内核事件表中,参数enable_et指定是否对fd启用ET模式
void addfd(int epollfd, int fd){
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLLET;
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
setnonblocking(fd);
}
// 信号处理函数
void sig_handler(int sig){
// 保留原来的errno,在函数最后回复,保证函数的可重入性
int save_errno = errno;
int msg = sig;
send(epollfd, (char*)&msg, 1, 0); // 将信号值写入管道,以通知主循环
errno = save_errno;
}
void addsig(int sig, void(*handler)(int), bool restart = true){
struct sigaction sa;
memset(&sa, '\0', sizeof(sa));
sa.sa_handler = handler;
if(restart){
sa.sa_flags |= SA_RESTART;
}
sigfillset(&sa.sa_mask);
assert(sigaction(sig, &sa, NULL)!=-1);
}
void del_resource(){
close(sig_pipefd[0]);
close(sig_pipefd[1]);
close(listenfd);
close(epollfd);
shm_unlink(shm_name);
delete [] users;
delete [] sub_process;
}
// 停止一个子进程
void child_term_handler(int sig){
stop_child = true;
}
// 子进程运行函数,idx为子进程处理的客户链接编号,share_mem是共享内存的起始地址
int run_child(int idx, client_data* users, char* share_mem){
epoll_event events[MAX_EVENT_NUMBER];
// 子进程使用I/O复用技术同时监听两个文件描述符:客户连接socket、与父进程通信的管道文件描述符
int child_epollfd = epoll_creat(5);
assert(child_epollfd != -1);
int connfd = users[idx].connfd;
addfd(child_epollfd, connfd);
int pipefd = users[idx].pipefd[1];
addfd(child_epollfd, pipefd);
int ret;
// 子进程设置自己的信号处理函数
addsig(SIGTERM, child_term_handler, false);
while(!stop_child){
int number = epoll_wait(child_epollfd, events, MAX_EVENT_NUMBER, -1);
if((number<0)&&(errno!=EINTR)){
printf("epoll failure\n");
break;
}
for(int i=0;i<number;i++){
int sockfd = events[i].data.fd;
// 本子进程负责的客户链接有数据到达
if((sockfd==connfd)&&(events[i].events&EPOLLIN)){
memset(share_mem+idx*BUFFER_SIZE,'\0',BUFFER_SIZE);
//将客户数据读取到对应的读缓存中
ret = recv(connfd, share_mem+idx*BUFFER_SIZE, BUFFER_SIZE-1, 0);
if(ret<0){
if(errno!=EAGAIN){
stop_child = true;
}
}
else if(ret==0){
stop_child = true;
}
else{
// 成功读取客户数据后就通知主进程来处理
send(pipefd, (char*)&idx, sizeof(idx), 0);
}
}
// 主进程通知本进程将第client个客户数据发送到本进程负责的客户端
else if((sockfd==pipefd)&&(events[i].events&EPOLLIN)){
int client = 0;
// 接收主进程发送来的数据
ret = recv(sockfd, (char*)&client, sizeof(client), 0);
if(ret<0){
if(errno!=EAGAIN){
stop_child = true;
}
}
else if(ret == 0){
stop_child = true;
}
else{
send(connfd, share_mem+client*BUFFER_SIZE, BUFFER_SIZE,0);
}
}
else{
continue;
}
}
}
close(connfd);
close(pipefd);
close(child_epollfd);
return 0;
}
int main(int argc, char* argv[]){
if(argc<=2){
printf("usage: %s ip_address port_number \n", basename(argv[0]));
return 1;
}
const char* ip = argv[1];
int port = atoi(argv[2]);
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = socket(PF_INET, SOCK_STERAM, 0);
assert(listenfd>=0);
ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
assert(ret!=-1);
ret = listen(listenfd, 5);
assert(ret!=-1);
user_count = 0;
users = new client_data[USER_LIMIT+1];
sub_process = new int[PROCESS_LIMIT];
for(int i=0;i<PROCESS_LIMIT;i++){
sub_process[i] = -1;
}
epoll_event events[MAX_EVENT_NUMBER];
epollfd = epoll_create(5);
assert(epollfd != -1);
addfd(epollfd, listenfd);
ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sig_pipefd);
assert(ret != -1);
setnonblocking(sig_pipefd[1]);
addfd(epollfd, sig_pipefd[0]);
addsig(SIGCHLD, sig_handler);
addsig(SIGTERM, sig_handler);
addsig(SIGINT, sig_handler);
addsig(SIGPIPE, SIG_IGN);
bool stop_server = false;
bool terminate = false;
// 创建共享内存,作为所有客户socket连接的读缓存
shmfd = shm_open(shm_name, O_CREAT | O_RDWR, 0666);
assert(shmfd = -1);
ret = ftruncate(shmfd, USER_LIMIT*BUFFER_SIZE);
assert(ret != -1);
share_mem = (char*)mmap(NULL, USER_LIMIT*BUFFER_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, shmfd, 0);
assert(share_mem!=MAP_FAILED);
close(shmfd);
while(!stop_server){
int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
if((number<0)&&(errno!=EINTR)){
printf("epoll failure\n");
break;
}
for(int i=0;i<number;i++){
int sockfd = events[i].data.fd;
// 新客户连接到来
if(sockfd == listenfd){
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
if(connfd < 0){
printf("errno is : %d\n", errno);
continue;
}
if(user_count>=USER_LIMIT){
const char* info = "too many users\n";
printf("%s", info);
send(connfd, info, strlen(info), 0);
close(connfd);
continue;
}
// 保存第user_count个客户连接的相关数据
users[user_count].address = client_address;
users[user_count].connfd = connfd;
// 在主进程和子进程间建立管道,以传递必要的数据
ret = socketpair(PF_UNIX, SOCK_STREAM, 0, users[user_count].pipefd);
assert(ret != -1);
pip_t pid = fork();
if(pid < 0){
close(connfd);
continue;
}
else if(pid == 0){
close(epollfd);
close(listenfd);
close(users[user_count].pipefd[0]);
close(sig_pipefd[0]);
close(sig_pipefd[1]);
run_child(user_count, users, share_mem);
munmap((void*)share_mem, USER_LIMIT*BUFFER_SIZE);
exit(0);
}
else{
close(connfd);
close(users[user_count].pipefd[1]);
addfd(epollfd, users[user_count].pipefd[0]);
users[user_count].pid = pid;
// 记录新客户连接在数组users中的因所致
sub_process[pid] = user_count;
user_count++;
}
}
// 处理信号事件
else if((sockfd==sig_pipefd[0])&&(events[i].events&EPOLLIN)){
int sig;
char signals[1024];
ret = recv(sig_pipefd[0], signals, sizeof(signals), 0);
if(ret == -1){
continue;
}
else if(ret == 0){
continue;
}
else{
for(int i=0;i<ret;i++){
switch (signals[i]){
// 子进程退出,标识有某个客户端关闭了连接
case SIGCHLD:{
pid_t pid;
int stat;
while((pid=waitpid(-1, &stat, WNOHANG))>0){
// 用子进程的pid获取被关闭的客户连接编号
int del_user = sub_process[pid];
sub_process[pid] = -1;
if((del_user<0)||(del_user>USER_LIMIT)){
continue;
}
// 清除第del_user个客户连接使用的相关数据
epoll_ctl(epollfd, EPOLL_CTL_DEL, users[del_user].pipefd[0], 0);
close(users[del_user].pipefd[0]);
users[del_user] = users[--user_count];
sub_process[users[del_user].pid] = del_user;
}
if(terminate && user_count==0){
stop_server = true;
}
break;
}
case SIGTERM:
case SIGINT:{
// 结束服务其程序
printf("kill all the clild now\n");
if(user_count==0){
stop_server = true;
break;
}
for(int i=0;i<user_count;i++){
int pid = users[i].pid;
kill(pid, SIGTERM);
}
terminate = true;
break;
}
default:{
break;
}
}
}
}
}
// 某个子进程向父进程写入了数据
else if(events[i].events*EPOLLIN){
int child = 0;
// 读取管道数据,child变量记录哪个客户有数据到达
ret = recv(sockfd, (char*)&child, sizeof(child), 0);
printf("read data from child accross pipe\n");
if(ret == -1){
continue;
}
else if(ret == 0){
continue;
}
else{
// 向除负责第child个客户连接的子进程外的其他进程发送数据,通知其有客户数据要写
for(int j=0;j<user_count;j++){
if(users[j].pipefd[0]!=sockfd){
printf("send data to child accross pipe\n");
send(users[j].pipefd[0],(char*)&child, sizeof(child),0);
}
}
}
}
}
}
del_resource();
return 0;
}
消息队列是两个进程之间传递二进制块数据的一种简单有效的方式,每个数据块都有一个特定的类型,可以根据类型来选择地接收数据。
#include <sys/msg.h>
// 创建一个消息队列或获取一个已有的消息队列。
int msgget(key_t key, int msgflg);
// 内联结构体
struct msqid_ds{
struct ipc_perm msg_perm; // 消息队列的操作权限
time_t msg_stime;
time_t msg_rtime;
time_t msg_ctime;
unsigned long __msg_cbytes;
msgqnum_t msg_qnum;
msglen_t msg_qbytes;
pid_t msg_lspid;
pid_t msg_lrpid;
};
#include <sys/msg.h>
// 将一条消息添加到消息队列中
int msgsend(int msqid, const void* msg_ptr, size_t msg_sz, int msgflg);
// msg_ptr指向准备发送的消息,其定义必须如下类型
struct msgbuf{
long mtype; // 消息类型
char mtext[512]; // 消息数据
};
#include <sys/msg.h>
// 从消息队列中获取消息
int msgrcv(int msqid, void* msg_ptr, size_t msg_sz, long int msgtype, int msgflg);
#include <sys/msg.h>
// 控制消息队列的某些属性
int msgctl(int msqid, int command, struct msqid_ds* buf);
&sudo ipcs
实例:在进程间传递文件描述符
#include <sys/sockte.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
static const int CONTROL_LEN = CMSG_LEN(sizof(int));
// 发送文件描述符,fd参数用来传递UNINX域socket,fd_to_send是待发送的文件描述符
void send_fd(int fd, int fd_to_send){
struct iovec iov[i];
struct msghdr msg;
char buf[0];
iov[0].iov_base = buf;
iov[0].iov_len = 1;
msg.mag_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
cmsghdr cm;
cm.cmsg_len = CONTROL_LEN;
cm.cmsg_level = SOL_SOCKET;
cm.cmsg_type = SCM_RIGHTS;
*(int*)CMSG_DATA(&cm) = fd_to_send;
msg.msg_control = &cm; // 设置辅助数据
msg.msg_controllen = CONTROL_LEN;
sendmsg(fd, &msg, 0);
}
// 接受目标文件描述符
int recv_fd(int fd){
struct iovec iov[1];
struct msghdr msg;
char buf[0];
iov[0].iov_base = buf;
iov[0].iov_len = 1;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
cmsghdr cm;
msg.msg_control = &cm;
msg.msg_controllen = CONTROL_LEN;
recvmsg(fd, &msg, 0);
int fd_to_read = *(int*)CMSG_DATA(&cm);
return fd_to_read;
}
int main(){
int pipefd[2];
int fd_to_pass = 0;
// 创建父子进程之间的管道
int ret = socketpair(PF_UNIX, SOCK_DGRAM, 0, pipefd);
assert(ret != -1);
pid_t pid = fork();
assert(pid>=0);
if(pid == 0){
close(pipefd[0]);
fd_to_pass = open("test.txt", O_RDWR, 0666);
// 子进程通过管道将文件描述符发送到父进程
// 如果文件test.txt打开失败,则子进程将标准输入文件描述符发送到父进程
send_fd(pipefd[1], (fd_to_pase>0)?fd_to_pass:0);
close(fd_to_pass);
exit(0);
}
close(pipefd[1]);
fd_to_pass = recv_fd(pipefd[0]); // 父进程从管道接受目标文件描述符
char buf[1024];
memset(buf, '\0', 1024);
read(fd_to_pass, buf, 1024); // 读取目标文件描述符
printf("I got fd %d and data %s \n", fd_to_pass, buf);
close(fd_to_pass);
}
文章浏览阅读645次。这个肯定是末尾的IDAT了,因为IDAT必须要满了才会开始一下个IDAT,这个明显就是末尾的IDAT了。,对应下面的create_head()代码。,对应下面的create_tail()代码。不要考虑爆破,我已经试了一下,太多情况了。题目来源:UNCTF。_攻防世界困难模式攻略图文
文章浏览阅读2.9k次,点赞3次,收藏10次。偶尔会用到,记录、分享。1. 数据库导出1.1 切换到dmdba用户su - dmdba1.2 进入达梦数据库安装路径的bin目录,执行导库操作 导出语句:./dexp cwy_init/[email protected]:5236 file=cwy_init.dmp log=cwy_init_exp.log 注释: cwy_init/init_123..._达梦数据库导入导出
文章浏览阅读1.9k次。1. 在官网上下载KindEditor文件,可以删掉不需要要到的jsp,asp,asp.net和php文件夹。接着把文件夹放到项目文件目录下。2. 修改html文件,在页面引入js文件:<script type="text/javascript" src="./kindeditor/kindeditor-all.js"></script><script type="text/javascript" src="./kindeditor/lang/zh-CN.js"_kindeditor.js
文章浏览阅读2.3k次,点赞6次,收藏14次。SPI的详情简介不必赘述。假设我们通过SPI发送0xAA,我们的数据线就会变为10101010,通过修改不同的内容,即可修改SPI中0和1的持续时间。比如0xF0即为前半周期为高电平,后半周期为低电平的状态。在SPI的通信模式中,CPHA配置会影响该实验,下图展示了不同采样位置的SPI时序图[1]。CPOL = 0,CPHA = 1:CLK空闲状态 = 低电平,数据在下降沿采样,并在上升沿移出CPOL = 0,CPHA = 0:CLK空闲状态 = 低电平,数据在上升沿采样,并在下降沿移出。_stm32g431cbu6
文章浏览阅读1.2k次,点赞2次,收藏8次。数据链路层习题自测问题1.数据链路(即逻辑链路)与链路(即物理链路)有何区别?“电路接通了”与”数据链路接通了”的区别何在?2.数据链路层中的链路控制包括哪些功能?试讨论数据链路层做成可靠的链路层有哪些优点和缺点。3.网络适配器的作用是什么?网络适配器工作在哪一层?4.数据链路层的三个基本问题(帧定界、透明传输和差错检测)为什么都必须加以解决?5.如果在数据链路层不进行帧定界,会发生什么问题?6.PPP协议的主要特点是什么?为什么PPP不使用帧的编号?PPP适用于什么情况?为什么PPP协议不_接收方收到链路层数据后,使用crc检验后,余数为0,说明链路层的传输时可靠传输
文章浏览阅读587次。软件测试工程师移民加拿大 无证移民,未受过软件工程师的教育(第1部分) (Undocumented Immigrant With No Education to Software Engineer(Part 1))Before I start, I want you to please bear with me on the way I write, I have very little gen...
文章浏览阅读304次。Thinkpad X250笔记本电脑,装的是FreeBSD,进入BIOS修改虚拟化配置(其后可能是误设置了安全开机),保存退出后系统无法启动,显示:secure boot failed ,把自己惊出一身冷汗,因为这台笔记本刚好还没开始做备份.....根据错误提示,到bios里面去找相关配置,在Security里面找到了Secure Boot选项,发现果然被设置为Enabled,将其修改为Disabled ,再开机,终于正常启动了。_安装完系统提示secureboot failure
文章浏览阅读10w+次,点赞93次,收藏352次。1、用strtok函数进行字符串分割原型: char *strtok(char *str, const char *delim);功能:分解字符串为一组字符串。参数说明:str为要分解的字符串,delim为分隔符字符串。返回值:从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。其它:strtok函数线程不安全,可以使用strtok_r替代。示例://借助strtok实现split#include <string.h>#include <stdio.h&_c++ 字符串分割
文章浏览阅读2.3k次。1 .高斯日记 大数学家高斯有个好习惯:无论如何都要记日记。他的日记有个与众不同的地方,他从不注明年月日,而是用一个整数代替,比如:4210后来人们知道,那个整数就是日期,它表示那一天是高斯出生后的第几天。这或许也是个好习惯,它时时刻刻提醒着主人:日子又过去一天,还有多少时光可以用于浪费呢?高斯出生于:1777年4月30日。在高斯发现的一个重要定理的日记_2013年第四届c a组蓝桥杯省赛真题解答
文章浏览阅读851次,点赞17次,收藏22次。摘要:本文利用供需算法对核极限学习机(KELM)进行优化,并用于分类。
文章浏览阅读1.1k次。一、系统弱密码登录1、在kali上执行命令行telnet 192.168.26.1292、Login和password都输入msfadmin3、登录成功,进入系统4、测试如下:二、MySQL弱密码登录:1、在kali上执行mysql –h 192.168.26.129 –u root2、登录成功,进入MySQL系统3、测试效果:三、PostgreSQL弱密码登录1、在Kali上执行psql -h 192.168.26.129 –U post..._metasploitable2怎么进入
文章浏览阅读257次。本文将为初学者提供Python学习的详细指南,从Python的历史、基础语法和数据类型到面向对象编程、模块和库的使用。通过本文,您将能够掌握Python编程的核心概念,为今后的编程学习和实践打下坚实基础。_python人工智能开发从入门到精通pdf