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重叠！