walk

最新推荐文章于 2024-05-22 18:38:27 发布
最新推荐文章于 2024-05-22 18:38:27 发布
阅读量727 收藏
点赞数
分类专栏： SS 文章标签： s SNMP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yourbog/article/details/19720255
版权



void req_send(snmp_req *req)  
{
int ret = 0, n = 0, m = 0;
int liberr, syserr;
struct snmp_session Session;
struct snmp_pdu *pdu;
oid anOID[MAX_OID_LEN];
void *sessp = NULL;
struct timeval timeout;
timeout.tv_usec = 0;
timeout.tv_sec = req->snmpdata->timeout;
int fds = 0, block = 1;  
fd_set fdset;
char* ipaddr;
char* community;
char portstr[10] = { 0 };


if (!req->sessp)
{
snmp_sess_init(&Session);  

Session.version = req->snmpdata->version;
Session.retries = req->snmpdata->retries;
Session.callback = snmp_get_callback;
Session.callback_magic = req;
Session.timeout = req->snmpdata->timeout * 1000000L;
Session.remote_port = req->snmpdata->port;


n = wcslen(req->snmpdata->ipaddr);
m = sprintf(portstr, "%u",req->snmpdata->port);
ipaddr = calloc(sizeof(char), n + m + 1);//
ret = wcstombs(ipaddr, req->snmpdata->ipaddr, n);
*(ipaddr+n) = ':';//
strcat(ipaddr, portstr);//
Session.peername = ipaddr;
if (-1 == ret) {
req->snmpdata->result = XFAERR_WCSTOMBS;
ret = -1;
//LOG 出力
goto done;
}


n = wcslen(req->snmpdata->community);
community = calloc(sizeof(char), n);
ret = wcstombs(community, req->snmpdata->community, n);
Session.community = (u_char*)community;
if (-1 == ret) {
req->snmpdata->result = XFAERR_WCSTOMBS;
//LOG 出力
ret = -1;
goto done;
}


Session.community_len = strlen((char*)Session.community);


sessp = snmp_sess_open(&Session);
if (sessp == NULL) {  
/* Error codes found in open calling argument */  
snmp_error(&Session, &syserr , &liberr, NULL);  
req->snmpdata->syserr = syserr;  
req->snmpdata->liberr = liberr;
req->snmpdata->result = XFAERR_NETSNMPERR;
ret = -1;
goto done;  
} 
req->sessp = sessp;
}
sessp = req->sessp;
if (req->snmpdata->walkflag == XFA_SNMP_GETNEXT_RESPONE) {
pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
if (!pdu) {
g_errline = __LINE__;
req->snmpdata->syserr = errno;
req->snmpdata->result = XFAERR_NETSNMPERR;
ret = -1;
goto done;
}
if (req->snmpdata->data) {//add to end or begine 
for(n = 0; n < req->snmpdata->data->oidlen; n++) {
anOID[n] = *(req->snmpdata->data->oid+n);
}
snmp_add_null_var(pdu, anOID, req->snmpdata->data->oidlen);
} 
else {
for(n = 0; n < req->snmpdata->oidlen; n++) {
anOID[n] = *(req->snmpdata->oid+n);
}
snmp_add_null_var(pdu, anOID, req->snmpdata->oidlen);
}
} else {
pdu = snmp_pdu_create(SNMP_MSG_GET);
if (!pdu) {
g_errline = __LINE__;
req->snmpdata->syserr = errno;
req->snmpdata->result = XFAERR_NETSNMPERR;
ret = -1;
goto done;
}
for(n = 0; n < req->snmpdata->oidlen; n++) {
anOID[n] = *(req->snmpdata->oid+n);
}
snmp_add_null_var(pdu, anOID, req->snmpdata->oidlen);
}


if (0 == snmp_sess_send(sessp, pdu)) {
snmp_sess_error(sessp, &syserr,&liberr, NULL);
g_errline = __LINE__;
req->snmpdata->liberr = liberr;
req->snmpdata->result = XFAERR_NETSNMPERR;
req->snmpdata->syserr = syserr;
snmp_free_pdu(pdu);
ret = -1;
goto done;
}
req->status = 1;
snmp_sess_select_info(sessp, &fds, &fdset, &timeout, &block);
req->snmpfd = fds - 1;


done:
if (ret == -1) {
snmp_sess_close(sessp);
if (Session.peername) {
free(Session.peername);
Session.peername = NULL;
}
if (Session.community) {
free(Session.community);
Session.community = NULL;
}


notify_ap(req); //bug when snmp_sess_send failed but callbalk function been called anyway.
}
return;  
} 


void res_read(int snmpfd)
{  
fd_set fdset;
int liberr, syserr;
snmp_req *tmp = NULL;


//ここでg_reqListをロックしない
tmp = g_reqList;
while(tmp) {
if (snmpfd == tmp->snmpfd) {
break;
}
tmp = tmp->next;
}


if (!tmp) {
goto done;
}


FD_ZERO(&fdset);
FD_SET(snmpfd, &fdset);
if (snmp_sess_read(tmp->sessp, &fdset) == -1) {
snmp_sess_error(tmp->sessp, &syserr,&liberr, NULL);
tmp->snmpdata->liberr = liberr;
tmp->snmpdata->syserr = syserr;
tmp->snmpdata->result = XFAERR_NETSNMPERR;
}

if (tmp->status == 2) {
notify_ap(tmp);
snmp_sess_close(tmp->sessp);//sessp re creat
}
//snmp_sess_close(tmp->sessp);//sessp re creat
done:
return;
}


void *snmp_get_thread(void *arg)
{
fd_set fdset;
int sdAll[FD_SETSIZE] = { 0 };
int i, j, m, n;
char buf[64];
int maxfd = -1;
snmp_req *tmp, *sendtmp;
struct timeval timeout;


while(g_terminateflag) {
FD_ZERO(&fdset);
FD_SET(g_reqfd, &fdset);
maxfd = g_reqfd;
i = 0;


//ここでg_reqListをロックしない
sendtmp = tmp = g_reqList;
while (tmp) {
if (tmp->status == 1) {
if (tmp->snmpfd > maxfd) {
maxfd = tmp->snmpfd;
}
FD_SET(tmp->snmpfd, &fdset);
sdAll[i++] = tmp->snmpfd;
}
tmp = tmp->next;
}


if ( (n = select(maxfd+1, &fdset, NULL, NULL, &timeout)) > 0) {
if (FD_ISSET(g_reqfd, &fdset)) {
while (1) {
m = recvfrom(g_reqfd, buf, sizeof(buf), 0, NULL, NULL);
if (m <= 0) {
break;
}
}


while(sendtmp) {//ここでg_reqListをロックしない
if (2 != sendtmp->status) {
req_send(sendtmp);
}
sendtmp = sendtmp->next;
}
} else {
for (j = 0; j < i; j ++) {
if (FD_ISSET(sdAll[j], &fdset)) {
res_read(sdAll[j]);
}
}
}
} else if (n == -1) {

} else {
res_read_timeout();
}
}


return (void *)1;
}


int xfa_snmp_init(void)
{
int ret = 0;
void *res = NULL;
int s = 1, tnum;
pthread_attr_t attr;
socklen_t addrlen;
struct sockaddr_in addr;
#ifdef WIN32
SYSTEM_INFO si;
#endif


//ミューテックス初期化
ret = pthread_mutex_init(&g_mutex_ini, NULL);
if (ret) {
g_errline = __LINE__;
ret = XFAERR_BADMUTEX;
goto done;
}


pthread_mutex_lock(&g_mutex_ini);
if (g_initflag == 1) {
pthread_mutex_unlock(&g_mutex_ini);
goto done;
}
pthread_mutex_unlock(&g_mutex_ini);


SOCK_STARTUP;


ret = pthread_mutex_init(&g_mutex_req, NULL);
if (ret) {
g_errline = __LINE__;
ret = XFAERR_BADMUTEX;
goto done;
}


g_reqfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (g_reqfd == -1) {
g_errline = __LINE__;
ret = XFAERR_BADSOCKET;
goto done;
}
if ((ret = ioctl(g_reqfd, FIONBIO, &s)) < 0) {
g_errline = __LINE__;
ret = XFAERR_BADSOCKET;
goto done;
}
memset(&addr, 0, sizeof(struct sockaddr_in));
addrlen = sizeof(struct sockaddr_in);
addr.sin_family = AF_INET;
addr.sin_port = htons(0);
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
ret = bind(g_reqfd, (struct sockaddr *) &addr, addrlen);
if (ret != 0) {
g_errline = __LINE__;
ret = XFAERR_BADSOCKET;
goto done;
}
addrlen = sizeof(struct sockaddr_in);
ret = getsockname(g_reqfd, (struct sockaddr *) &g_listenaddr, &addrlen);
if (ret != 0) {
g_errline = __LINE__;
ret = XFAERR_BADSOCKET;
goto done;
}


ret = pthread_attr_init(&attr);
if (ret != 0) {
g_errline = __LINE__;
ret = XFAERR_BADTHREAD;
goto done;
}
#ifndef WIN32  //LINUX,HP-UX 対応  
for (tnum = 0; tnum < MAX_THREAD_COUND; tnum++) {
g_pThreadInfo[tnum].thread_num = tnum + 1;
ret = pthread_create(&g_pThreadInfo[tnum].thread_id, &attr, snmp_get_thread, &g_pThreadInfo[tnum]);
if (ret != 0) {
g_errline = __LINE__;
ret = XFAERR_BADTHREAD;
goto done;
}
}
g_terminateflag = 1;
ret = pthread_attr_destroy(&attr);
if (ret != 0) {
g_errline = __LINE__;
ret = XFAERR_BADTHREAD;
goto done;
}
#else  //WINODWS 対応
//
//
#endif


done:
if (ret < 0) {
SOCK_CLEANUP;
if (g_reqfd) {
close(g_reqfd);
g_reqfd = 0;
}
pthread_mutex_destroy(&g_mutex_req);
pthread_mutex_destroy(&g_mutex_ini);
for (tnum = 0; tnum < MAX_THREAD_COUND; tnum++) {
s = pthread_join(g_pThreadInfo[tnum].thread_id, &res);
}


} else {
g_terminateflag = 1;
pthread_mutex_lock(&g_mutex_ini);
g_initflag = 1;
pthread_mutex_unlock(&g_mutex_ini);
}
return ret;
}


xfa_snmpdata* xfa_snmpdata_alloc(wchar_t* ipaddr, 
unsigned short port, 
long version,
wchar_t* community,
unsigned long* oid, 
int retries,
long timeout,
int walkflag,
int oidlen)
{ 
xfa_snmpdata* snmpdata = NULL;
int ret = 0;


snmpdata = (xfa_snmpdata*)calloc(sizeof(xfa_snmpdata), 1);
if (!snmpdata) {
ret = -1;
goto done;
}


//ipv6チェック必要
if (ipaddr) {
if (wcschr(ipaddr, L':')) {
ret = -1;
goto done;
}
snmpdata->ipaddr = ipaddr;
} else {
ret = -1;
goto done;
}
snmpdata->port = port;


if (!oidlen || oidlen > 255) {
ret = -1;
goto done;
}
snmpdata->oidlen = oidlen;

if (walkflag != XFA_SNMP_GET_RESPONE && walkflag != XFA_SNMP_GETNEXT_RESPONE) {
ret = -1;
goto done;
}
snmpdata->walkflag = walkflag;


if (version != XFA_SNMP_VERSION_1 && version != XFA_SNMP_VERSION_2c) {
ret = -1;
goto done;
}
snmpdata->version = version;


snmpdata->community = community;

if (oid) {
snmpdata->oid = oid; 
} else {
ret = -1;
goto done;
}

if (retries < 0) {
ret = -1;
goto done;
}
snmpdata->retries = retries;

if (timeout < 0) {
ret = -1;
goto done;
}
snmpdata->timeout = timeout;


snmpdata->eventfd = 0;
snmpdata->result = 0;
snmpdata->liberr = 0;
snmpdata->syserr = 0;
snmpdata->data = NULL;


done:
if (ret < 0) {
if (snmpdata) {
free(snmpdata);
snmpdata = NULL;
}
return NULL;
} else {
return snmpdata;
}
}


int xfa_snmp_get(xfa_snmpdata *data)
{
snmp_req* req = NULL;
int ret = 0;
int eventfd = 0, s = 1;


//INIT Check
pthread_mutex_lock(&g_mutex_ini);
if (!g_initflag) {
ret = XFAERR_NOINIT;
goto done;
}
pthread_mutex_unlock(&g_mutex_ini);


//NULL Check
if (!data) {
ret = XFAERR_BADARG;
goto done;
}


eventfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (eventfd == -1) {
ret = XFAERR_BADSOCKET;
goto done;
}
if ((ret = ioctl(eventfd, FIONBIO, &s)) < 0) {
g_errline = __LINE__;
ret = XFAERR_BADSOCKET;
goto done;
}


if (!(req = (snmp_req*)calloc(sizeof(snmp_req), 1))) {
ret = XFAERR_NOBUFS;
goto done;
}
req->snmpdata = data;
req->snmpfd = 0;
req->sessp = NULL;
req->status = 0;
req->snmpdata->eventfd = eventfd;


pthread_mutex_lock(&g_mutex_req);
queue_add((void**)&g_reqList,(void*)req);
pthread_mutex_unlock(&g_mutex_req);


//WorkerThreadへ通知する
if (sendto(eventfd, "S", 1, 0,(struct sockaddr *)&g_listenaddr,sizeof(g_listenaddr)) == -1) {
ret = XFAERR_BADSOCKET;
goto done;
}


done:
if (ret < 0) {
if (eventfd) {
close(eventfd);
eventfd = 0;
}
if (data){
data->eventfd = 0;
}
if (req) {
free(req);
req = NULL;
}
return ret;
} else {
return eventfd;
}
}


void res_read_timeout(void)
{
snmp_req *tmp = NULL;


//ここでg_reqListをロックしない
tmp = g_reqList;
while (tmp) {
if (tmp->status != 0) {
snmp_sess_timeout(tmp->sessp);
}
tmp= tmp->next;
}
return;
}


int xfa_snmp_cleanup(void)
{
int tnum, ret = 0;
void* res = NULL;
snmp_req *reqtmp1 = NULL, *reqtmp2 = NULL;
xfa_mibdata *mibtmp1 = NULL, *mibtmp2 = NULL;


if (!g_initflag) {
ret = XFAERR_NOINIT;
goto done;
}
pthread_mutex_lock(&g_mutex_ini);
g_initflag = 0;
if (g_reqfd) {
close(g_reqfd);
g_reqfd = -1;
}
//WorkerThread終了マーク設定
g_terminateflag = 0;


//WorkerThread終了を待つ
for (tnum = 0; tnum < MAX_THREAD_COUND; tnum++) {
pthread_join(g_pThreadInfo[tnum].thread_id, &res);
}
//資源クリーン
pthread_mutex_lock(&g_mutex_req);
reqtmp1 = g_reqList;
while (reqtmp1) {
if (reqtmp1->sessp) { //Net snmp free
free(reqtmp1->sessp);
reqtmp1->sessp = NULL;
}
if (reqtmp1->snmpdata) {
if (reqtmp1->snmpdata->data) {
mibtmp1 = reqtmp1->snmpdata->data;
while(mibtmp1) {
if (mibtmp1->str){
free(mibtmp1->str);
mibtmp1->str = NULL;
}
if (mibtmp1->value){
free(mibtmp1->value);
mibtmp1->value = NULL;
}
mibtmp2 = mibtmp1->next;
free(mibtmp1);
mibtmp1 = mibtmp2;
}
}
if (reqtmp1->snmpdata->eventfd) {
close(reqtmp1->snmpdata->eventfd);
reqtmp1->snmpdata->eventfd = 0;
}
}
queue_del((void**)&g_reqList, (void*)reqtmp1);
reqtmp2 = reqtmp1->next;
free(reqtmp1); //bug
reqtmp1 = reqtmp2;
}
g_reqList = NULL;
pthread_mutex_unlock(&g_mutex_req);


SOCK_CLEANUP;
pthread_mutex_unlock(&g_mutex_ini);
pthread_mutex_destroy(&g_mutex_req);
pthread_mutex_destroy(&g_mutex_ini);


done:
return ret;
}


int xfa_mibdata_to_str(
  xfa_mibdata *data,
  unsigned int codePage,
  wchar_t** value)
{
int n, m, i;
int isHex = 0;
unsigned char c;
char *s;
unsigned int tt, uu, ss, mm, hh;
char str[1024] = { 0 };


if (!data || !value || !data->value || !data->str) {
return XFAERR_BADARG;
}
setlocale(LC_ALL, /*"ca_ES.utf8"*/NULL);//set codepage
//str = data->str;


switch(data->type) {
case XFA_MIBTYPE_OCTETSTRING:
case XFA_MIBTYPE_OPAQUE:
for (i = 0; i < data->len; i++) {
m =(int) *((unsigned char*)data->value+i);
if (isprint(m)) {
continue;
} else {
isHex = 1;
break;
}
}
if (isHex) {
n = 0;
str[n++] = '0';
str[n++] = 'x';
for (i = 0; i < data->len; i++) {
c = *((unsigned char*)data->value+i);
str[n++] = dig2hex[(c & 0xf0) >> 4];
str[n++] = dig2hex[c & 0x0f];
str[n++] = L':';
}
str[n-1] = '\0';
} else {
for (i = 0; i <data->len; i++) {
str[i] = *(((unsigned char*)data->value)+i);
}
str[i] = '\0';
}
break;
case XFA_MIBTYPE_IPADDRESS:
sprintf(str, "%u.%u.%u.%u", *((unsigned char*)data->value+0), *((unsigned char*)data->value+1), *((unsigned char*)data->value+2), *((unsigned char*)data->value+3));
break;


case XFA_MIBTYPE_OBJECT_IDENTIFIER:
if (data->len > 128) {
break;
}
str[0] = '\0';
for (i = 0; i < data->len/8; i++) {
sprintf(s,"%d", *((int*)data->value+(i*2)));
strcat(str,s);
strcat(str,".");
}
s = strrchr(str,(int)'.');
*s = '\0';
break;
case XFA_MIBTYPE_TIMETICKS:
// TimeTicks
//L"hh:mm:ss.uu"
tt = *((unsigned long *)data->value);
ss = tt / 100; uu = tt % 100;
mm = ss / 60;  ss = ss % 60;
hh = mm / 60;  mm = mm % 60;
(void) sprintf(str, "%u:%02u:%02u.%02u", hh, mm, ss, uu);
break;
default:break;
}


mbstowcs(data->str, str, strlen(str));
*value = data->str;
return XFAERR_NOERR;
}


int xfa_mibdata_to_int(
  xfa_mibdata *data,
  int *value)
{
if (!data || !value || data->type != XFA_MIBTYPE_INTEGER) {
return XFAERR_BADARG;
} else {
if (data->value) {
*value = *((int*)data->value);
} else {
return XFAERR_BADARG;
}
}
return XFAERR_NOERR;
}




int xfa_mibdata_to_uint(
xfa_mibdata *data,
unsigned int *value)
{
if (!data || !value || data->type != 0x41 || data->type != 0x42) {
return XFAERR_BADARG;
} else {
*value = *((unsigned int*)data->value);
}
return XFAERR_NOERR;
}




int xfa_mibdata_to_ulonglong(
xfa_mibdata *data,
unsigned long long *value)


{
if (!data || !value || data->type != XFA_MIBTYPE_COUNTER64) {
return XFAERR_BADARG;
} else {
*value = *((unsigned long long*)data->value);
}
return XFAERR_NOERR;
}
hejian1106
关注
专栏目录
net-snmp库snmp API解读分析
rheostat的专栏
09-06 3321
net-snmp库snmp API解读分析   导读 net-snmp API分为两种，一种叫传统API(Traditional API)，一种叫单个API（Single API）。早期的neet-snmp没有考虑到多线程的问题，所有的会话共享同一个资源，这些就是传统API，后来支持多线程的就叫做单个API。详细的内容在源码根目录下的README.thread文件里有详细介绍，这里贴出一部分
Net-Snmp多线程以及异步的使用
CC_fighting的博客
03-14 2199
最近使用到了Net-Snmp来做一个设备信息查询的manager，因为在使用的时候查询的设备以及需要的oid比较多，使用同步的方式一个一个查询会使查询速度慢，所以在这里有两种解决方式。 多线程 因为刚开始使用Net-snmp不是很熟悉，所以立马想到的就是使用多个线程提高并发。 关于多线程的API，可以在Net-SNMP的rREADME文档看到如下内容： Traditional...
snmpwalk之timeout问题
haodong_cc的博客
05-24 2万+
【使用环境】kali linux 2018.1【snmpwalk版本】  Version:  5.7.3【用法】snmpwalk [参数] &lt;目标ip&gt; [OID]【注意】在自己搭建的环境中使用snmpwalk的时候出现了timeout: no response from x.x.x.x请注意以下几点：(1) 确保你的kali已经启动了snmpd.service服务。(2) 确保目标w...
snmpwalk 语法
最新发布
funnycoffee123的博客
05-22 278
1 背景snmpwalk是SNMP的一个工具，它使用SNMP的GETNEXT请求查询指定OID（SNMP协议中的对象标识）入口的所有OID树信息，并显示给用户。通过snmpwalk也可以查看支持SNMP协议（可网管）的设备的一些其他信息，比如cisco交换机或路由器IP地址、内存使用率等。
DeepWalk
颹蕭蕭
10-13 1587
《DeepWalk: Online Learning of Social Representations》
SnmpWalk.zip_SNMP_snmp WALK_snmpwalk _snmpwalk实现
07-15
这个压缩包"SnmpWalk.zip"可能包含了一个关于`snmpwalk`的实现以及测试程序，名为"testSNMP++ - 副本"。 `snmpwalk`操作基于SNMP协议的GETNEXT请求，它会从指定的OID（Object Identifier）开始，连续获取MIB树中的...
dibian,Ubuntu版本的snmpwalk的安装介质，安装包，及说明文档
02-01
`snmpwalk`是SNMP工具集的一部分，用于遍历网络设备上的MIB（Management Information Base）树，获取设备状态信息。在Ubuntu或Debian系统中，我们可以按照以下步骤安装和使用`snmpwalk`。 首先，我们需要了解提供的...
net-snmp,snmpwalk(windows最新版本)
03-02
该工具是运行于windows平台的exe可执行文件，跟linux平台的snmpwalk功能类似，使用方法：cmd→cd到该exe文件的目录→snmpwalk.exe + option（通过snmpwalk.exe -h可以获得相关参数及运用方法，包括version、...
ubuntu18.04下snmpwalk离线安装deb文件
10-28
SNMPwalk是基于SNMP协议的一个实用工具，它允许用户遍历网络上的设备，获取关于设备配置和状态的详细信息。在没有互联网连接的情况下，离线安装SNMPwalk可能会变得有些复杂，但通过以下步骤，你可以顺利在Ubuntu ...
SNMP_WALK获取SNMP协议oid的非常好用的工具
06-22
"SNMP_WALK"是利用SNMP协议进行数据查询的一个功能，它能够遍历设备的MIB（Management Information Base）树，获取指定OID（Object Identifier，对象标识符）的所有子节点信息。 SNMP_WALK工具通常是一个命令行实用...
SNMP的基本知识介绍
02-27 2421
1.1. SNMP概览 <br />SNMP的基本知识介绍<br />简单网络管理协议（SNMP－Simple Network Management Protocol)是一个与网络设备交互的简单方法。该规范是由IETF在1990年五月发布的RFC 1157中定义的。SNMP通常被认为相当难懂，并且过于复杂，其可用的API似乎在本来非常简单的东西外面封装了大量的东西。现在关于SNMP的书籍又往往只是把它更加复杂化了，而没有解释清楚。<br />SNMP对于任何程序设计人员来说是特别易于理解的。总体的简化能够很
如何解决zabbix snmp异常超时、不稳定、时通时断：Timeout
weixin_30527323的博客
02-15 2605
针对平时工作中，zabbix snmp出现异常超时、不稳定、时通时断：Timeout while connecting 等的情况，以下我将以使用乐维监控为例，进行解决方案的详细叙述。 一、问题：设备SNMP不通 网络设备SNMP不通Timeout while connecting to"192.168.1.99:161". 1.1检查配置 1....
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 7150
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
Visual Studio 2022 有哪些新功能？
热门推荐
学海无涯苦作舟的博客
02-09 2万+
Visual Studio 2022现已与它支持的 .NET 6 一起正式发布。它包括许多新功能和改进，例如可以为您自动完成代码块的 AI IntelliCode。 您可以 从他们的网站下载安装程序。虽然它仍然是新的，但它仍然是 Visual Studio，所以除非您依赖尚未更新的扩展，否则不要害怕尝试一下。 我们将介绍我们发现的最重要的更改，但如果您想逐行阅读补丁说明，可以从 Microsoft 的文档中进行。还有一个描述总体方向的路线图。 终于64位了 Visual Studio 一直是 32 位的，.
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1781
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
Servlet和jsp--用户信息管理系统
行行失故路
02-23 2663
目录 系统整体结构图 1. 登录 1.1 登录界面演示 1.2 html前端 1.3 servlet 2. 查询所有用户信息 2.1 页面演示 2.2 html前端 2.3 servlet 3. 添加功能 3.1 页面演示 3.2 html前端 3.3 servlet 4. 删除功能 4.1 页面演示 4.2 html前端 4.3 servlet 5. 修改功能 5.1 页面演示 5.2 html前端 5.3 servlet 6. 删除选中..
SNMPWalk详解：网络设备管理工具
"SnmpWalk是一款用于网络设备SNMP变量扫描的工具，它能列举出任何网络设备上可读的SNMP变量。该软件由SnmpSoft Company开发，并且允许用户免费安装和使用，但需随附许可证。" 在本文档中，我们将深入探讨SnmpWalk的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值