c語言linuxudp

Ⅰ linux c語言實現，udp協議

UDP協議全稱是用戶數據報協議，在網路中它與TCP協議一樣用於處理數據包，是一種無連接的協議。在OSI模型中，在第四層--傳輸層，處於IP協議的上一層。UDP有不提供數據包分組、組裝和不能對數據包進行排序的缺點，也就是說，當報文發送之後，是無法得知其是否安全完整到達的。UDP用來支持那些需要在計算機之間傳輸數據的網路應用。包括網路視頻會議系統在內的眾多的客戶/伺服器模式的網路應用都需要使用UDP協議。UDP協議從問世至今已經被使用了很多年，雖然其最初的光彩已經被一些類似協議所掩蓋，但是即使是在今天UDP仍然不失為一項非常實用和可行的網路傳輸層協議。

Ⅱ linux下udp通信的客戶端、伺服器端的c語言程序 用int argc，char *argv[] 能夠輸入ip和埠號

占個位置，晚上回去給你發，我做的是C語言的socket通信的小程序，我是先創建了一個守護進程，我的守護進程，做的任務就是你所說的中轉程序的工作，通信的客戶端，先把消息發給守護進程，再由守護進程轉發給另一個客戶端。
守護進程：
守護進程，也就是通常說的Daemon進程，是Linux中的後台服務進程。它是一個生存期較長的進，通常獨立於控制終端並且周期性地執行某種任務或等待處理某些發生的事件。守護進程常常在系統引導裝入時啟動，在系統關閉時終止。Linux系統有很多守護進程，大多數服務都是通過守護進程實現的，同時，守護進程還能完成許多系統任務，例如，作業規劃進程crond、列印進程lqd等（這里的結尾字母d就是Daemon的意思）。
由於在Linux中，每一個系統與用戶進行交流的界面稱為終端，每一個從此終端開始運行的進程都會依附於這個終端，這個終端就稱為這些進程的控制終端，當控制終端被關閉時，相應的進程都會自動關閉。但是守護進程卻能夠突破這種限制，它從被執行開始運轉，直到整個系統關閉時才退出。如果想讓某個進程不因為用戶或終端或其他地變化而受到影響，那麼就必須把這個進程變成一個守護進程。

Ⅲ 請教用C語言編的藉助UDP協議實現的文件傳輸的程序

本程序在 Windows 7 Visual Studio 2015 和 Linux Ubuntu 15.04 GCC 5.11 下均編譯運行測試通過。

本程序支持 Windows 和 Linux 之間傳送文件，如果要在 Windows 和 Linux 之間傳送文件，文件名不能出現中文。

本程序支持無線 WiFi，支持 USB 收發器，但僅支持區域網內傳送文件，傳送文件需要輸入對方的 IP 地址。

本程序包括伺服器端和客戶端，既可以發送文件又可以接收文件。如果要在同一台機器上測試需要同時打開兩個程序。

Windows 下查看本機 IP 地址的命令是：

ipconfig

Linux 下查看本機 IP 地址的命令是：

ifconfig

以下是程序代碼：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

#ifdef_MSC_VER
#include<winsock2.h>
#include<windows.h>
#pragmacomment(lib,"ws2_32.lib")
#else
#include<pthread.h>
#include<unistd.h>
#include<signal.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#endif

//存放發送接收字元數組大小
#defineSIZEA65501
//每次發送接收位元組數
#defineSIZEB65500

typedefstructsockaddr_inSockAddrIn;
SockAddrInserverAddr,remoteAddr,clientAddr;

//埠號
intiServerPort,iClientPort;
//新建socket信息
intiUDP;

//字元串轉整型
intstrToInt(char*acStr)
{
inti,iIndex=0,iNum=0,iSize=0;
if(acStr[0]=='+'||acStr[0]=='-')
iIndex=1;

for(iSize=iIndex;;iSize++)
if(acStr[iSize]<'0'||acStr[iSize]>'9')
break;

for(i=iIndex;i<iSize;i++)
iNum+=(int)pow(10,iSize-i-1)*(acStr[i]-48);

if(acStr[0]=='-')
iNum=-iNum;

returniNum;
}

//整型轉字元串
voidintToStr(intiInt,char*acStr)
{
intiIndex=0,iSize,iNum,iBit,i,j;

if(iInt<0)
{
acStr[0]='-';
iInt=-iInt;
iIndex=1;
}
for(i=0;;i++)
if(iInt<pow(10,i))
break;
iSize=i;

for(i=0;i<iSize;i++)
{
iNum=pow(10,iSize-i-1);
iBit=iInt/iNum;
iInt-=iNum*iBit;
acStr[i+iIndex]=iBit+48;
}
if(iSize!=0)
acStr[iSize+iIndex]='';
else
{
acStr[0]='0';
acStr[1]='';
}
}

voidsleepUDP(intiSleep)
{
#ifdef_MSC_VER
Sleep(iSleep);
#else
usleep(iSleep*1000);
#endif
}

voidopenUDP(char*acIpAddr)
{
#ifdef_MSC_VER
//Winsows啟用socket
WSADATAwsadata;
if(WSAStartup(MAKEWORD(1,1),&wsadata)==SOCKET_ERROR)
{
printf("啟用socket失敗
");
exit(0);
}
#endif

//新建socket
if((iUDP=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP))==-1)
{
printf("新建socket失敗
");
exit(0);
}

//清零
memset(&serverAddr,0,sizeof(serverAddr));
memset(&clientAddr,0,sizeof(clientAddr));

//設置協議IP地址及Port
serverAddr.sin_family=AF_INET;
serverAddr.sin_port=htons(iServerPort);
serverAddr.sin_addr.s_addr=htonl(INADDR_ANY);

clientAddr.sin_family=AF_INET;
clientAddr.sin_port=htons(iClientPort);
clientAddr.sin_addr.s_addr=inet_addr(acIpAddr);

//綁定埠，監聽埠
if(bind(iUDP,(structsockaddr*)&serverAddr,sizeof(serverAddr))==-1)
{
printf("綁定埠失敗
");
exit(0);
}
}

voidcloseUDP(void)
{
#ifdef_MSC_VER
//Winsows關閉socket
closesocket(iUDP);
WSACleanup();
#endif
}

//要發送的字元串
characSendStr[SIZEA];
//接收到的字元串
characRecvStr[SIZEA];
//請求信息
characReq[SIZEA];
//文件名字元串
characFileName[SIZEA];
//文件位元組數字元串
characFileSize[SIZEA];

intiSize,iNameSize;

//接收文件名
#ifdef_MSC_VER
DWORDWINAPIrecvName(LPVOIDp)
#else
void*recvName(void*arg)
#endif
{
intiAddrSize=sizeof(remoteAddr);
acReq[0]='n';acReq[1]='a';acReq[2]='m';acReq[3]='e';acReq[4]='';
acRecvStr[0]='';
printf("%s
","正在發送請求信息！");
//發送請求信息
sendto(iUDP,acReq,strlen(acReq),0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
//每次發送請求信息後等待一段時間
sleepUDP(10);
//接收文件名
iSize=recvfrom(iUDP,acRecvStr,SIZEB,0,(structsockaddr*)&remoteAddr,&iAddrSize);
return0;
}

//接收文件
voidrecvFile(char*acDirName,char*acIpAddr)
{
FILE*pFile=NULL;
inti,iFileSize,iRecvNum,iAddrSize=sizeof(remoteAddr);
//路徑文件名
characDirAndFileName[SIZEA];

openUDP(acIpAddr);
//接收文件名
for(;;)
{
//創建線程
#ifdef_MSC_VER
HANDLEhThread;
DWORDthreadId;
hThread=CreateThread(NULL,0,recvName,0,0,&threadId);
//每次發送後等待一段時間
sleepUDP(1000);
//強制終止線程
TerminateThread(hThread,0);
#else
pthread_tthread;
void*thread_arg=(pthread_t)0;
pthread_create(&thread,NULL,recvName,(void*)&thread_arg);
//每次發送後等待一段時間
sleepUDP(1000);
//強制終止線程
pthread_cancel(thread);
#endif
if(acRecvStr[0]!='')
{
acRecvStr[iSize]='';
printf("文件名為：%s
",acRecvStr);
break;
}
}

acDirAndFileName[0]='';
strcat(acDirAndFileName,acDirName);
//連接路徑名和文件名
strcat(acDirAndFileName,acRecvStr);
//如果已經有這個文件了就清空文件內容
pFile=fopen(acDirAndFileName,"w");
fclose(pFile);

acReq[0]='s';acReq[1]='i';acReq[2]='z';acReq[3]='e';acReq[4]='';
//接收文件位元組數
for(;;)
{
//發送請求信息
sendto(iUDP,acReq,strlen(acReq)+1,0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
//每次發送請求信息後等待一段時間
sleepUDP(10);
//接收文件位元組數
acRecvStr[0]='';
iSize=recvfrom(iUDP,acRecvStr,SIZEB,0,(structsockaddr*)&remoteAddr,&iAddrSize);
if(acRecvStr[0]!='')
{
acRecvStr[iSize]='';
iFileSize=strToInt(acRecvStr);
printf("文件位元組數為：%d
",iFileSize);
break;
}
}

//以追加方式寫入文件
pFile=fopen(acDirAndFileName,"ab");
//文件分幾次接收
iRecvNum=iFileSize/SIZEB;
//接收文件
for(i=0;i<iRecvNum;i++)
{
intToStr(i,acReq);
for(;;)
{
//發送請求信息
sendto(iUDP,acReq,strlen(acReq)+1,0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
printf("%s	正在接收文件的第%d段
",acReq,i);
//每次發送請求信息後等待一段時間
sleepUDP(10);
//接收一段文件
iSize=recvfrom(iUDP,acRecvStr,SIZEB,0,(structsockaddr*)&remoteAddr,&iAddrSize);
if(iSize==SIZEB)
{
//以追加方式寫入文件
fwrite(acRecvStr,sizeof(char),iSize,pFile);
break;
}
}
}
//接收文件剩餘位元組
iSize=iFileSize%SIZEB;
if(iSize>0)
{
acReq[0]='l';acReq[1]='a';acReq[2]='s';acReq[3]='t';acReq[4]='';
for(;;)
{
//發送請求信息
sendto(iUDP,acReq,strlen(acReq)+1,0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
//每次發送請求信息後等待一段時間
sleepUDP(10);
//接收文件剩餘位元組
if(recvfrom(iUDP,acRecvStr,iSize,0,(structsockaddr*)&remoteAddr,&iAddrSize)==iSize)
{
//以追加方式寫入文件
fwrite(acRecvStr,sizeof(char),iSize,pFile);
break;
}
}
}
printf("%s
","文件接收完畢！");

//關閉文件
fclose(pFile);
//關閉連接
closeUDP();
}

//發送文件名
#ifdef_MSC_VER
DWORDWINAPIsendName(LPVOIDp)
#else
void*sendName(void*arg)
#endif
{
intiAddrSize=sizeof(remoteAddr);
acRecvStr[0]='';
//接收請求
printf("%s
","正在接收請求信息！");
recvfrom(iUDP,acRecvStr,5,0,(structsockaddr*)&remoteAddr,&iAddrSize);
//每次接收請求信息後等待一段時間
sleepUDP(10);
//如果請求信息正確發送文件名
if(acRecvStr[0]=='n'&&acRecvStr[1]=='a'&&acRecvStr[2]=='m'&&acRecvStr[3]=='e'&&acRecvStr[4]=='')
sendto(iUDP,acFileName,iNameSize,0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
return0;
}

//發送文件
voidsendFile(char*acDirAndFileName,char*acIpAddr)
{
inti,j,iFileSize,iSendNum,iAddrSize=sizeof(remoteAddr);
FILE*pFile=NULL;

pFile=fopen(acDirAndFileName,"rb");
fseek(pFile,0,SEEK_END);
//文件位元組數
iFileSize=ftell(pFile);
intToStr(iFileSize,acFileSize);
//printf("%s
",acDirAndFileName);

//獲取文件名長度
iSize=strlen(acDirAndFileName);
for(i=iSize-1,iNameSize=0;i>=0;i--,iNameSize++)
if(acDirAndFileName[i]=='\'||acDirAndFileName[i]=='/')
break;
//printf("%d
",iNameSize);

//截取文件名
for(i=0;i<iNameSize;i++)
acFileName[i]=acDirAndFileName[iSize-iNameSize+i];
acFileName[iNameSize]='';
//printf("%s
",acFileName);

openUDP(acIpAddr);
//發送文件名
for(;;)
{
//創建線程
#ifdef_MSC_VER
HANDLEhThread;
DWORDthreadId;
hThread=CreateThread(NULL,0,sendName,0,0,&threadId);
//每次接收請求信息後等待一段時間
sleepUDP(1000);
//強制終止線程
TerminateThread(hThread,0);
#else
pthread_tthread;
void*thread_arg=(pthread_t)0;
pthread_create(&thread,NULL,sendName,(void*)&thread_arg);
//每次接收請求信息後等待一段時間
sleepUDP(1000);
//強制終止線程
pthread_cancel(thread);
#endif
//如果請求信息正確退出循環
if(acRecvStr[0]=='n'&&acRecvStr[1]=='a'&&acRecvStr[2]=='m'&&acRecvStr[3]=='e'&&acRecvStr[4]=='')
break;
}
//發送文件位元組數
for(;;)
{
acRecvStr[0]='';
//接收請求
recvfrom(iUDP,acRecvStr,5,0,(structsockaddr*)&remoteAddr,&iAddrSize);
//每次接收請求信息後等待一段時間
sleepUDP(10);
//如果請求信息正確
if(acRecvStr[0]=='s'&&acRecvStr[1]=='i'&&acRecvStr[2]=='z'&&acRecvStr[3]=='e'&&acRecvStr[4]=='')
{
//發送文件位元組數
sendto(iUDP,acFileSize,strlen(acFileSize),0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
break;
}
}

iSendNum=iFileSize/SIZEB;
//發送文件
if(iSendNum>0)
{
for(i=0;;i++)
{
acRecvStr[0]='';
//接收請求
recvfrom(iUDP,acRecvStr,SIZEB,0,(structsockaddr*)&remoteAddr,&iAddrSize);
printf("%s	正在發送文件的第%d段
",acRecvStr,i);
//每次接收請求信息後等待一段時間
sleepUDP(10);
fseek(pFile,strToInt(acRecvStr)*SIZEB,SEEK_SET);
fread(acSendStr,1,SIZEB,pFile);
//printf("%s
",acSendStr);
//發送一段文件
sendto(iUDP,acSendStr,SIZEB,0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
if(strToInt(acRecvStr)>=iSendNum-1)
break;
}
}
//發送文件剩餘位元組
iSize=iFileSize%SIZEB;
if(iSize>0)
{
for(;;)
{
acRecvStr[0]='';
//接收請求
recvfrom(iUDP,acRecvStr,5,0,(structsockaddr*)&remoteAddr,&iAddrSize);
//每次接收請求信息後等待一段時間
sleepUDP(10);
//如果請求信息正確
if(acRecvStr[0]=='l'&&acRecvStr[1]=='a'&&acRecvStr[2]=='s'&&acRecvStr[3]=='t'&&acRecvStr[4]=='')
{
fseek(pFile,iSendNum*SIZEB,SEEK_SET);
fread(acSendStr,1,iSize,pFile);
//printf("%s
",acSendStr);
//發送文件剩餘位元組
sendto(iUDP,acSendStr,iSize,0,(structsockaddr*)&clientAddr,sizeof(clientAddr));
break;
}
}
}
printf("%s
","文件發送完畢！");

//關閉連接
closeUDP();
}

intmain(void)
{
characDirName[SIZEA];
characDirAndFileName[SIZEA];
characIpAddr[15];
inti,iOption=0,iSize=0;
FILE*pFile=NULL;
charcLast='\';

option:
printf("%s
","****************************************************
本程序包括伺服器端和客戶端，既可以發送文件又可以接收文件。
支持無線WiFi，支持USB收發器，但僅支持區域網內傳送文件。
如果要在Windows和Linux之間傳送文件，文件名不能出現中文。
如果要在同一台機器上測試需要同時打開兩個程序。
****************************************************");
printf("%s
","請輸入選項，1.發送文件、2.接收文件。");
scanf("%d",&iOption);

//發送文件
if(iOption==1)
{
iServerPort=1025;
iClientPort=1024;
fileName:
printf("%s
","請輸入需要發送的路徑文件名。
Windows路徑文件名格式：		C:\install.txt
Linux路徑文件名格式：		/home/install.txt");
scanf("%s",acDirAndFileName);
pFile=fopen(acDirAndFileName,"rb");
if(pFile==NULL)
{
printf("%s
","讀取文件失敗，請重新輸入文件名。");
gotofileName;
}
//關閉文件
fclose(pFile);

printf("%s
","請輸入接收文件方的IP地址，不能有空格。
例如：
192.168.1.104");
scanf("%s",acIpAddr);

sendFile(acDirAndFileName,acIpAddr);
}
//接收文件
elseif(iOption==2)
{
iServerPort=1024;
iClientPort=1025;
dirName:
printf("%s
","請輸入保存文件的路徑名。
Windows路徑名格式：		C:\img\
Linux路徑名格式：		/home/");
scanf("%s",acDirName);

iSize=strlen(acDirName);
//檢查是不是Linux路徑名
for(i=0;i<iSize;i++)
{
if(acDirName[i]=='/')
{
cLast='/';
break;
}
}
//檢查路徑名最後一個字元是不是或/
if(acDirName[iSize-1]!=cLast)
{
acDirName[iSize]=cLast;
acDirName[iSize+1]='';
}
acDirAndFileName[0]='';
strcat(acDirAndFileName,acDirName);
strcat(acDirAndFileName,"a.txt");
//試探保存一個無關緊要的文件
pFile=fopen(acDirAndFileName,"w");
if(pFile==NULL)
{
printf("%s
","該路徑無法創建文件，請重新輸入路徑名。");
gotodirName;
}
else
{
//關閉文件
fclose(pFile);
//刪除文件
remove(acDirAndFileName);
}

printf("%s
","請輸入發送文件方的IP地址，不能有空格。
例如：
192.168.2.249");
scanf("%s",acIpAddr);

recvFile(acDirName,acIpAddr);
}
else
{
printf("%s
","沒有這個選項，請重新輸入。");
gotooption;
}

return0;
}

Ⅳ Linux下的c語言UDP編程

read是直接讀取文件，scanf系列函數本身也得用read讀取文件。

bind是把socket和地址關聯，INADDR_ANY的意思是任何地址。比如你的設備有很多ip，客戶端向其中任何一個發送數據你的socket都能接收到。相應地如果你bind一個確定的ip的話，向其他ip發送數據你的socket是接收不到的。

Ⅳ 學嵌入式linux需要先學什麼

韋東山：6000字長文告訴你如何學習嵌入式linux

鏈接：網頁鏈接

第1章 單片機和Linux的區別

1.1 有哪些產品使用單片機或Linux

所有的電子產品，所用技術都可以認為要麼是單片機，要麼是Linux；GUI方面主要是QT/Android，它們都是運行於Linux之上的。

下面我們用類比和邏輯推導出嵌入式Linux系統的組成，沒錯，「推導」。

從上圖可以知道：

① 組成：

嵌入式Linux系統

= bootloader + linux內核 + 根文件系統(裡面含有APP)。

② bootloader：

它的目的是啟動內核，去哪等讀內核？讀到哪裡？去Flash等外設讀內核，存到內存里去。所以需要有Flash里外設的驅動能力，為了調試方便還會有網路功能。

所以，可以認為 booloader = 裸機集合，它就是一個復雜的單片機程序。

③ Linux內核

Linux內核的最主要目的是去啟動APP，APP保存在哪裡？保存在「根文件系統」里。「根文件系統」又保存在哪裡？在Flash、SD卡等設備里，甚至可能在網路上。所以Linux內核要有這些Flash、SD卡里設備的驅動能力。

不僅如此，Linux內核還有進程調度能力、內存管理等功能。

所以：Linux內核 = 驅動集合 + 進程調度 + 內存管理等。

2.3 要學習bootloader嗎

Bootloader有很多種，常用的叫作u-boot。

在實際工作中，對於u-boot基本上是修修改改，甚至不改。但是u-boot本身是很復雜的，比如為了便於調試，它支持網路功能；有些內核是保存在FAT32分區里，於是它要能解析FAT32分區，讀FAT32分區的文件。

花那麼多精力去學習u-boot，但是工作中基本用不到，這對初學者很不友善。

所以，對於初學者，我建議：理解u-boot的作用、會使用u-boot的命令，這就可以了。

如果你的工作就是修改、完善bootloader，那麼再去研究它吧。

2.4 要學習Linux內核、要學習驅動程序嗎

之前我們說過Linux內核 = 驅動集合 + 進程調度 + 內存管理等，如果要學習Linux內核，從驅動程序入手是一個好辦法。

但是人人都要學習Linux內核、人人都要學習Linux驅動嗎？顯然不是。

作為初學者，懂幾個簡單的驅動程序，有利於工作交流；理解中斷、進程、線程的概念，無論是對驅動開發、應用程序開發，都是很有好處的。

所以對於初學者，建議前期只學習這幾個驅動：LED、按鍵、中斷。

① LED驅動程序：

這是最簡單的驅動程序。

② 按鍵驅動程序：

它也比較簡單，從它引入「中斷」。

③ 中斷：

從「中斷」它可以引入：休眠-喚醒、進程/線程、POLL機制、非同步通知等概念。這些概念無論是對驅動開發，還是對應用開發，都很重要。

所以，對於初學者，我建議必須學習這幾個驅動：LED、按鍵、中斷。

入門之後，如果你想從事內核開發、驅動開發，那麼可以去鑽研幾個驅動程序(輸入系統、I2C匯流排、SPI匯流排等)，掌握若干個大型驅動程序後，你對內核的套路就有所了解了，再去研究其他部分(比如進程管理、文件系統)時你會發現套路是如此通用。

攝像頭(VL42)、音效卡ALSA驅動是Linux中比較復雜的2類驅動，它們是很難的，如果工作與此相關再去研究。

2.5，要學習Linux應用程序嗎？先學一些基礎技能

要學，即使以後你只想研究內核，一些基本的應用開發編寫能力也是需要的：

① 基本設備的訪問，比如LCD、輸入設備

② 進程、線程、進程通信、線程同步與互斥

③ 休眠-喚醒、POLL機制、信號

④ 網路編程

①②③部分的知識，跟驅動有密切的關系，它們是相輔相承的。

掌握了基本驅動開發能力、基本應用開發能力之後，在工作中你就可以跟別人友好溝通了，不至於一臉懵逼。

2.6，應用程序是怎麼啟動的？要了解一下根文件系統

你辛辛苦苦寫出了應用程序，怎麼把它放到板子上，讓它開機就自動啟動？

你寫的程序，它依賴於哪些庫，這些庫放到板子上哪個目錄？

怎麼做一個可升級的系統？即使升級中途斷電了，也要保證程序至少還可以運行老的版本？

這些都需要我們了解一下根文件系統。

先了解一下init進程：它要讀取配置文件，根據配置文件啟動各個APP。

了解了init進程，你就了解了根文件系統的組成，就可以隨心所欲裁剪系統，為你的項目製作出最精簡的系統。

第3章 學習方法

3.1，先不要打破砂鍋問到底

嵌入式涉及的東西太多太雜了，如果心裡沒有主線，碰到什麼都要去研究個透徹，最終反而忘記自己要學什麼了。

嵌入式涉及硬體知識、軟體知識，軟體里涉及匯編、ARM架構、C語言、Makefile、Shell；又分為bootloader、內核、驅動、基本的APP、GUI。

比如我們會用到Makefile，了解它的基本規則，會用我們提供的Makefile就可以。

不需要深入研究那些make函數，因為在工作中都有現成的Makefile給你使用，不需要自己去編寫一套Makefile。何必花上好幾天去深入研究它呢？

比如我們會用到bootloader，難道又要花上幾個月來深入研究u-boot嗎？工作中基本不需要改u-boot，會用那幾個命令就可以。

甚至有些學員先去買本shell的書來學習shell命令，何必？我們在視頻中用到什麼命令，你不懂時再去網路一下這些命令就可以了。

不要脫離初學者的主線：應用基礎、驅動基礎。有了這2個基礎後，你想深入研究某部分時，再去花時間吧。

3.2，思路要清晰，不怕抄代碼

視頻里的代碼，請你一定要自己去寫一次、寫多次。為什麼我現在寫驅動那麼熟？我2009年在華清遠見上課時，

每次上課我都要給學生寫一次那些驅動，十幾次下來閉著眼睛都知道內核的套路了。

記不住那些函數？我也記不住，我都是去參考同類的驅動程序，這又不是閉卷考試。

但是要理清楚思路，你寫這個程序要完成什麼功能、怎麼實現這些功能？這個要弄清楚。

有了思路後再寫代碼，不知道怎麼寫？沒關系，看看視頻，看看示例，然後關閉視頻看看能否自己寫出來。

3.3，對自己的方向很了解，我只能帶你到這里了

我的專長是操作系統，是快速地帶領大家掌握一些項目開發的基礎知識。

如果你決定深入研究某方面時，我並不能帶你多久。你要去看源碼，去看這方面的專業書籍。

比如想深入鑽研內核的內存管理時，它有頁表映射(你需要閱讀ARM架構的手冊)、SLAB分配器、vmalloc/malloc實現、mmap實現、缺頁中斷、父進程子進程之間的頁面管理等等，內容非常多。有時候連書籍都沒有，你需要直接啃代碼。

當你想從事某個行業時，就需要深入研究行業相關的知識。

比如CAN匯流排，它可以寫成一本書：CAN協議、CAN報文、Socket CAN、車身網路拓撲結構，CAN應用報文，CAN網路管理報文，CAN診斷報文。

想做物聯網網關，需要深入研究MQTT，MQTT協議相對簡單，但是MQTT英文原版協議有130多頁，中文版有近100頁，是一本小書了。

每個行業都有自己的業務邏輯，在掌握基本的編程能力之一，你需要結合具體的業務去深入學習。

-☆ END ☆-

Ⅵ linux下如何編程向本地UDP埠發送命令

可以參考http://www.cnblogs.com/uvsjoh/archive/2013/01/01/2841764.html，基本流程和原理就是這樣，交叉編譯一下，下到板子上應該可以。

Ⅶ linux c中的socket監聽指定埠，協議udp

1. 使用recvfrom函數接收數據，它會同時返回對方的地址結構
   

2. 判斷數據的來源是不是目標埠即可。
   

Ⅷ udp非阻塞怎麼寫 linuxc語言

int flag=fcntl(fd,F_GETFL,0); flag |= O_NONBLOCK; if(fcntl(fd,F_SETFL,flag) < 0){ perror("fcntl"); exit(1); }

Ⅸ linux下udp實現文件的傳輸，盡量詳細點 思路我知道 就是不知道怎麼把文件名給傳過去

傳文件最好用個TCP。UDP會丟包的

////////////////////////////////////
//客戶端代碼
///////////////////////////////////

//本文件是客戶機的代碼
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
#include <time.h> //for time_t and time
#include <arpa/inet.h>

#define HELLO_WORLD_SERVER_PORT 7754
#define BUFFER_SIZE 1024

int main(int argc, char **argv)
{
if (argc != 2)
{
printf("Usage: ./%s ServerIPAddress\n",argv[0]);
exit(1);
}

//time_t now;
FILE *stream;

//設置一個socket地址結構client_addr,代表客戶機internet地址, 埠
struct sockaddr_in client_addr;
bzero(&client_addr,sizeof(client_addr)); //把一段內存區的內容全部設置為0
client_addr.sin_family = AF_INET; //internet協議族
client_addr.sin_addr.s_addr = htons(INADDR_ANY);//INADDR_ANY表示自動獲取本機地址
client_addr.sin_port = htons(0); //0表示讓系統自動分配一個空閑埠
//創建用於internet的流協議(TCP)socket,用client_socket代表客戶機socket
int client_socket = socket(AF_INET,SOCK_STREAM,0);
if( client_socket < 0)
{
printf("Create Socket Failed!\n");
exit(1);
}
//把客戶機的socket和客戶機的socket地址結構聯系起來
if( bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr)))
{
printf("Client Bind Port Failed!\n");
exit(1);
}

//設置一個socket地址結構server_addr,代表伺服器的internet地址, 埠
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family = AF_INET;
if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //伺服器的IP地址來自程序的參數
{
printf("Server IP Address Error!\n");
exit(1);
}
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
socklen_t server_addr_length = sizeof(server_addr);
//向伺服器發起連接,連接成功後client_socket代表了客戶機和伺服器的一個socket連接
if(connect(client_socket,(struct sockaddr*)&server_addr, server_addr_length) < 0)
{
printf("Can Not Connect To %s!\n",argv[1]);
exit(1);
}

char buffer[BUFFER_SIZE];
bzero(buffer,BUFFER_SIZE);

//從伺服器接收數據到buffer中
int length = recv(client_socket,buffer,BUFFER_SIZE,0);

if(length < 0)
{
printf("Recieve Data From Server %s Failed!\n", argv[1]);
exit(1);
}

printf("\n%s\n",buffer);

bzero(buffer,BUFFER_SIZE);

bzero(buffer,BUFFER_SIZE);
strcpy(buffer,"Hello, World! From Client\n");
//向伺服器發送buffer中的數據
send(client_socket,buffer,BUFFER_SIZE,0);

if((stream = fopen("data","w+t"))==NULL)
{
printf("The file 'data' was not opened! \n");
}

else
bzero(buffer,BUFFER_SIZE);
length = 0;
while( length = recv(client_socket,buffer,BUFFER_SIZE,0))
{
if(length < 0)
{
printf("Recieve Data From Server %s Failed!\n", argv[1]);
break;
}

int write_length = fwrite(buffer,sizeof(char),length,stream);
if (write_length<length)
{
printf("File is Write Failed\n");
break;
}
bzero(buffer,BUFFER_SIZE);
}
printf("Recieve File From Server[%s] Finished\n", argv[1]);

//關閉 文件
fclose(stream);

//關閉socket
close(client_socket);
return 0;
}

////////////////////////////////////
//伺服器代碼
///////////////////////////////////
//本文件是伺服器的代碼
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
#include <time.h> //for time_t and time

#define HELLO_WORLD_SERVER_PORT 7754
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024

int main(int argc, char **argv)
{
//設置一個socket地址結構server_addr,代表伺服器internet地址, 埠
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr)); //把一段內存區的內容全部設置為0
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
// time_t now;
FILE *stream;

//創建用於internet的流協議(TCP)socket,用server_socket代表伺服器socket
int server_socket = socket(AF_INET,SOCK_STREAM,0);
if( server_socket < 0)
{
printf("Create Socket Failed!");
exit(1);
}

//把socket和socket地址結構聯系起來
if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
{
printf("Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT);
exit(1);
}

//server_socket用於監聽
if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
{
printf("Server Listen Failed!");
exit(1);
}

while (1) //伺服器端要一直運行
{

struct sockaddr_in client_addr;
socklen_t length = sizeof(client_addr);

int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
if ( new_server_socket < 0)
{
printf("Server Accept Failed!\n");
break;
}

char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);

strcpy(buffer,"Hello,World! 從伺服器來！");
strcat(buffer,"\n"); //C語言字元串連接

send(new_server_socket,buffer,BUFFER_SIZE,0);

bzero(buffer,BUFFER_SIZE);
//接收客戶端發送來的信息到buffer中
length = recv(new_server_socket,buffer,BUFFER_SIZE,0);

if (length < 0)
{
printf("Server Recieve Data Failed!\n");
exit(1);
}
printf("\n%s",buffer);

if((stream = fopen("/home/administrator/110405A000.jpg","r"))==NULL)
{
printf("The file 'data1' was not opened! \n");
exit(1);
}
else

printf("The file 'filename' was opened! \n");
bzero(buffer,BUFFER_SIZE);

int lengsize = 0;
while((lengsize = fread(buffer,1,1024,stream)) > 0)
{

printf("lengsize = %d\n",lengsize);

if(send(new_server_socket,buffer,lengsize,0)<0)
{
printf("Send File is Failed\n");
break;
}

bzero(buffer, BUFFER_SIZE);

}
if(fclose(stream))
printf("The file 'data' was not closed! \n");
exit(1);

//關閉與客戶端的連接
close(new_server_socket);
}
//關閉監聽用的socket
close(server_socket);
return 0;
}