nc源碼

❶ 在c\c++程序里怎麼執行shell腳本命令

在C/C++源碼中執行shell命令，最基本的就是system()C庫函數，其次可以使用系統提供的api函數，比如windows上的createprocess shellexecuteex等函數，在linux上可以使用exec()等等．

下面是我在windows上的弄的一個測試版本，使用了線程，我感覺用nc來測試，不如直接netstat -an | findstr /I "udp" | findstr "22" ，因為22埠太其特了，很容易抓出來．另外nc判斷埠常規的作法就是nc -vv ip port 看提示信息就好了．

#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include <windows.h>
#include <process.h>
UINT __stdcall ThreadFunc(LPVOID lpParam) {
//將hacker字元串做為nc提交的數據
int ret = system("echo hacker | nc.exe -u 127.1 22");
//ret==0說明沒有開啟22埠
if (ret == 0 ) printf("nc: Write error: Connection refused.\n");
return 0;
}
int main()
{
HANDLE hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunc, 0, 0, 0);
//等待3秒鍾,說明22埠可用
WaitForSingleObject(hThread, 3000);
//結束測試線程
TerminateThread(hThread, 0);
//重新開啟NC連接22埠
system("nc.exe -vv -u 127.1 22");
return 0;
}

歡迎光臨0x30貼吧，一個高質量的計算機技術交流平台．

❷ 如何用VB寫出仿NC.exe的程序

用Winsock做,在左邊控制項面板上點右鍵,添加Microsoft Winsock Control 6這個組件,可以添加Winsock控制項
具體用法,http://blog.163.com/pb8318015/blog/static/10748776920097180811967/
但是用vb實現Nc是非常困難的，nc中涉及到對網路的很多較為底層的高級操作用vb是很難或者極麻煩實現的。勸你用c++，這根本找不到源碼。

❸ 找中值的c語言源代碼

#include<iostream>
#include<cstdlib>
#include<ctime>
#include<algorithm>

usingnamespacestd;


voidswap(intA[],inti,intj)
{
	if(i!=j)
	{
		intt=A[i];
		A[i]=A[j];
		A[j]=t;
	}
}

intpartition(intA[],intp,intr)
{
intx=A[r];
inti=p-1;
for(intj=p;j<=r-1;j++)
	{
		if(A[j]<=x)
		{
			i++;
			swap(A,i,j);
		}
	}
	swap(A,i+1,r);
	returni+1;
}

intrandomized_partition(intA[],intp,intr)
{
	srand(time(NULL));
	inti=p+rand()%(r-p+1);
	swap(A,i,r);
	returnpartition(A,p,r);
}

intrandomized_select(intA[],intp,intr,inti)
{
	if(p==r)returnA[p];
intq=randomized_partition(A,p,r);
intk=q-p+1;

if(i==k)returnA[q];
elseif(i<k)returnrandomized_select(A,p,q-1,i);
elsereturnrandomized_select(A,q+1,r,i-k);
}

voidtriplet_adjust(intA[],inti,intstep)
{
	intj=i+step;
intk=i+2*step;
if(A[i]<A[j])
	{
		if(A[k]<A[i])swap(A,i,j);
		elseif(A[k]<A[j])swap(A,j,k);
}
else
	{
		if(A[i]<A[k])swap(A,i,j);
		elseif(A[k]>A[j])swap(A,j,k);
	}
}

doublemean(intA[],intn)
{
	doublef=A[0];
	for(inti=1;i<n;i++)f+=A[i];
	returnf/n;
}

intapproximate_median(intA[],intr)
{
	intstep=1;
	intsize=1;
	inti;
for(intj=0;j<r;j++)size*=3;
for(intk=0;k<r;k++)
	{
		i=(step-1)/2;
		while(i<size)
		{
			triplet_adjust(A,i,step);
			i+=(3*step);
		}
		step*=3;
	}
	returnA[(size-1)/2];
}

voidselection_sort(intA[],intleft,intsize,intstep)
{
	intmin;
	inti,j;
	for(i=left;i<left+(size-1)*step;i+=step)
	{
		min=i;
		for(j=i+step;j<left+size;j+=step)
		{
			if(A[j]<A[min])min=j;
		}
		swap(A,i,j);
	}
}

template<classT,classS>
voidncmerge_sort(T*_A,S_N)
{
	Sstep,ins,l,m,r,pos0,pos1;
	T*_T=newT[_N];

	for(step=2;step<_N*2;step*=2)
	{
		for(l=0;l+step/2<_N;l+=step)
		{
			m=l+step/2;
			r=m+step/2<_N?m+step/2:_N;
			pos0=l;pos1=m;ins=0;
			while(pos0<m&&pos1<r)
{
				if(_A[pos1]<_A[pos0])_T[ins++]=_A[pos1++];
				else_T[ins++]=_A[pos0++];
			}
			while(pos0<m)_T[ins++]=_A[pos0++];
			while(pos1<r)_T[ins++]=_A[pos1++];
			while(ins>0)_A[--r]=_T[--ins];
		}
	}
	delete[]_T;
}
constintSORT_NUM_THRESHOD=50;

intapproximate_median_any_n(intA[],intsize)
{
	boolleft_to_right=false;
	intleft=0;
	intstep=1;
	inti;
	while(size>SORT_NUM_THRESHOD)
	{
		left_to_right=!left_to_right;
		intrem=size%3;
		if(left_to_right)i=left;
		elsei=left+(3+rem)*step;
		for(intj=0;j<(size/3-1);j++)
		{
			triplet_adjust(A,i,step);
			i+=3*step;
		}
if(left_to_right)left+=step;
else
		{
			i=left;
			left+=(1+rem)*step;
}
		selection_sort(A,i,3+rem,step);
		if(rem==2)
		{
			if(left_to_right)swap(A,i+step,i+2*step);
			elseswap(A,i+2*step,i+3*step);
		}
		step*=3;
		size=size/3;
	}
	selection_sort(A,left,size,step);
	returnA[left+step*int((size-1)/2)];
}

intmain(intargc,char*argv[])
{
	constintDEFAULT_N=50000000;
intN;
	if(argc<2)
	{
		N=DEFAULT_N;
	}
	else
	{
		N=atoi(argv[1]);
	}
	cout<<"N="<<N<<endl;
	clock_tt=clock();
	cout<<clock()<<endl;
	int*A=newint[N];
	cout<<clock()<<endl;
	srand(time(NULL));
	for(inti=0;i<N;i++)
	{
		A[i]=rand()%N;
	}

	clock_tt1=clock();
	cout<<t1<<endl;
	doubleavg=mean(A,N);
	cout<<avg<<endl;
	clock_tt2=clock();
	cout<<t2<<endl;
	intm=approximate_median_any_n(A,N);//近似中值選擇演算法，不太精確，但速度快點
	cout<<m<<endl;
	clock_tt3=clock();
	cout<<t3<<endl;
	m=randomized_select(A,0,N-1,N/2);//隨機選擇法
	cout<<m<<endl;
	clock_tt4=clock();
	cout<<t4<<endl;
	//std::sort(A,A+N);//標准快速排序
	ncmerge_sort(A,N);//原地並歸排序，排序法
	m=A[N/2];
	cout<<m<<endl;
	clock_tt5=clock();
	cout<<t5<<endl;
	cout<<endl;
	doubledt=(double)(t2-t1)/CLOCKS_PER_SEC;
	cout<<dt<<"";
	dt=(double)(t3-t2)/CLOCKS_PER_SEC;
	cout<<dt<<"";
	dt=(double)(t4-t3)/CLOCKS_PER_SEC;
	cout<<dt<<"";
	dt=(double)(t5-t4)/CLOCKS_PER_SEC;
	cout<<dt<<"";
	cout<<endl;

	return0;
}

❹ 如何使用源代碼構建一個可用的 Ubuntu 軟體包

用dpkg-source -x
foo.dsc從foo.orig.gz和foo.diff.gz創建工作目錄foo：一份發行版中立的源碼目錄，加上一個debian目錄以及目錄下的meta文件，就構成了一份可以生成二進制deb包的源碼工作目錄。其實從apt-get
source抓下來的目錄，已經是通過dpkg-source -x解壓過的了。dpkg-source
-x所做的主要事情就是1.解壓；2.把foo.diff.gz里的patch打到原始文件上。生成的foo目錄下的源文件，都已經是打過deb源碼包里的patch了的。
在foo目錄下，執行dpkg-buildpackage -us
-uc構建包。-us和-uc參數是不做簽名，適合於本地構建本地使用的情況。這個命令的輸出有兩個，一個是二進制deb包，另一個是源碼包，為什麼這里還要生成源碼包？因為你可能改動某些文件，那麼會生成新的diff.gz來記錄所有你針對原始源碼的改動，不管發布還是保存更改都更方便，下一次你只需要在生成的新的.dsc文件上執行dpkg-source -x就可以產生一個一模一樣的源碼了。如果你什麼都沒改動，那麼新產生的源碼包同你構建所來源的源碼包是一樣的。你也可以用參數-b和-S來控制這次構建只產生二進制包或者只產生源碼包。
兩個最重要的meta文件，debian/control和debian/rules。control文件決定了哪些二進制包將從這份源碼目錄中構建，一個源碼目錄往往是好幾個二進制包的輸入源。你不想生成哪個屏蔽它就行。二進制包的運行時依賴關系也在包的聲明中可見，並且control文件也聲明了構建過程中的依賴，不過可以給dpkg-buildpackage傳-d參數來忽略構建依賴。
debian/rules文件其實就是個Makefile，你可以執行make -f debian/rules target來單獨執行某個目標。rules文件里基本上都是對debhelper腳本函數的調用，像是dh_*這樣的函數，它們負責大部分的構建過程。常用的clean, install目標在rules文件中也有，有些基於源碼包的Makefile上所做的事情如make clean需要通過make -f debian/rules clean來代替。
和傳統意義的Make過程有點不一樣的就是，默認狀態下，每次dpkg-buildpackage，其實都是把從configure.ac生成configure腳本，到生成Makefile，到構建source，到安裝binary都做一遍，哪怕你並沒有改過configure.ac，或者改過源代碼.c文件，假如構建失敗了，就需要嘗試改動源代碼重新構建，有時候需要反復嘗試這個過程直到構建成功，如果包很大的話那需要花費的時間就很長，這時傳入-nc參數可以讓dpkg-buildpackage保留當前的構建結果，就像傳統的make一樣只會從出錯的地方重新開始。當然，當對源代碼的改動終止後，最後還是需要再執行一遍不帶-nc參數的命令」dpkg-buildpackage -us -uc」來重新完全構建一遍，否則在生成源碼包時可能會出錯。
dpkg-buildpackage不用擔心它會自動改變你的源文件（即通過dpkg-source
-x產生的文件），當然前提是你確實改動的是」源」文件，比如是configura.ac而不是configure，是dkms.conf.in而不是dkms.conf。
構建軟體時做得最多的事就是根據自己系統的需求調整./configure參數了吧，比如–enable–xxx或者–disable-xxx，在rules文件中，通過帶override前綴的target可以起到為默認的target定製參數的目的，如override_dh_auto_xconfigure:
對源碼包有修改最好通過dch -i來生成一個新的changelog文件，每個change item的title部分都是表示這次change的最新版本號，dpkg-buildpackage的輸出二進制包的版本號其實就是從changelog里提取的（不是寫在control文件里的）。

❺ 從源碼角度分析，為什麼會發生 Fragment 重疊

1、發生了頁面重啟（旋轉屏幕、內存不足等情況被強殺重啟）。2、使用add()方式載入Fragment；
為什麼會發生Fragment重疊？
從源碼角度分析，為什麼發生頁面重啟後會導致重疊？（在以add方式載入Fragment的時候）
我們知道Activity中有個onSaveInstanceState()方法，該方法在app進入後台、屏幕旋轉前、跳轉下一個
Activity等情況下會被調用，此時系統幫我們保存一個Bundle類型的數據，我們可以根據自己的需求，手動保存一些例如播放進度等數據，而後如果
發生了頁面重啟，我們可以在onRestoreInstanceState()或onCreate()里get該數據，從而恢復播放進度等狀態。

而產生Fragment重疊的原因就與這個保存狀態的機制有關，大致原因就是系統在頁面重啟前，幫我們保存了Fragment的狀態，但是在重啟後恢復時，視圖的可見狀態沒幫我們保存，而Fragment默認的是show狀態，所以產生了Fragment重疊現象。

分析： 我們先看FragmentActivity的相關源碼：
public class FragmentActivity extends ... {
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());

protected void onCreate(@Nullable Bundle savedInstanceState) {
...省略
if (savedInstanceState != null) {
Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);
mFragments.restoreAllState(p, nc != null ? nc.fragments : null);
}
}

@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
Parcelable p = mFragments.saveAllState();
...省略
}
}
從上面源碼可以看出，FragmentActivity確實是幫我們保存了Fragment的狀態，並且在頁面重啟後會幫我們恢復！

其中的mFragments是FragmentController，它是一個Controller，內部通過FragmentHostCallback間接控制FragmentManagerImpl。相關代碼如下：
public class FragmentController {
private final FragmentHostCallback<?> mHost;

public Parcelable saveAllState() {
return mHost.mFragmentManager.saveAllState();
}

public void restoreAllState(Parcelable state, List<Fragment> nonConfigList) {
mHost.mFragmentManager.restoreAllState(state, nonConfigList);
}
}

public abstract class FragmentHostCallback<E> extends FragmentContainer {
final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();
}
通過上面代碼可以看出FragmentController通過FragmentHostCallback里的FragmentManagerImpl對象來控制恢復工作。

我們接著看FragmentManagerImpl到底做了什麼：
final class FragmentManagerImpl extends FragmentManager {
Parcelable saveAllState() {
...省略 詳細保存過程
FragmentManagerState fms = new FragmentManagerState();
fms.mActive = active;
fms.mAdded = added;
fms.mBackStack = backStack;
return fms;
}

void restoreAllState(Parcelable state, List<Fragment> nonConfig) {
// 恢復核心代碼
FragmentManagerState fms = (FragmentManagerState)state;
FragmentState fs = fms.mActive[i];
if (fs != null) {
Fragment f = fs.instantiate(mHost, mParent);
｝
}
}
我們通過saveAllState()看到了關鍵的保存代碼，原來是是通過FragmentManagerState來保存Fragment的狀態、所處Fragment棧下標、回退棧狀態等。

而在restoreAllState()恢復時，通過FragmentManagerState里的FragmentState的instantiate()方法恢復了Fragment（見下面的分析就明白啦）

我們看下FragmentManagerState：
final class FragmentManagerState implements Parcelable {
FragmentState[] mActive; // Fragment狀態
int[] mAdded; // 所處Fragment棧下標
BackStackState[] mBackStack; // 回退棧狀態
...
}
我們只看FragmentState，它也實現了Parcelable，保存了Fragment的類名、下標、id、Tag、ContainerId以及Arguments等數據：
final class FragmentState implements Parcelable {
final String mClassName;
final int mIndex;
final boolean mFromLayout;
final int mFragmentId;
final int mContainerId;
final String mTag;
final boolean mRetainInstance;
final boolean mDetached;
final Bundle mArguments;
...

// 在FragmentManagerImpl的restoreAllState()里被調用
public Fragment instantiate(FragmentHostCallback host, Fragment parent) {
...省略
mInstance = Fragment.instantiate(context, mClassName, mArguments);
}
}
至此，我們就明白了系統幫我們保存的Fragment其實最終是以FragmentState形式存在的。

此時我們再思考下為什麼在頁面重啟後會發生Fragment的重疊？ 其實答案已經很明顯了，根據上面的源碼分析，我們會發現FragmentState里沒有Hidden狀態的欄位！

而Hidden狀態對應Fragment中的mHidden，該值默認false...
public class Fragment ... {
boolean mHidden;
}
我想你應該明白了，在以add方式載入Fragment的場景下，系統在恢復Fragment時，mHidden＝false，即show狀態，這
樣在頁面重啟後，Activity內的Fragment都是以show狀態顯示的，而如果你不進行處理，那麼就會發生Fragment重疊現象！
為什麼使用add()載入Fragment會導致重疊？
我們知道載入Fragment有2種方式：replace()和add()。使用replace載入Fragment是不會發生重疊現象的，只有通過add方式才有可能發生重疊現象。

我們一般使用add時，會和show(),hide()配合使用，add配合hide是使Fragment的視圖改變為GONE狀態；而
replace是銷毀Fragment
的視圖。頁面重啟時，add的Fragment會全部走生命周期，創建視圖；而replace的非棧頂Fragment不會走生命周期，只有Back時，
才會逐一走棧頂Fragment生命周期，創建視圖。

結合上面的源碼分析，在使用replace載入Fragment時，頁面重啟後，Fragment視圖都還沒創建，所以mHidden沒有意義，不
會發生重疊現象；而在使用add載入時，視圖是存在的並且疊加在一起，頁面重啟後
mHidden=false，所有的Fragment都會是show狀態顯示出來（即VISIBLE），從而造成了Fragment重疊！