Android读ipconfig.txt配置文件乱码

最新推荐文章于 2024-04-17 16:16:11 发布
最新推荐文章于 2024-04-17 16:16:11 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： Android10.0 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014630142/article/details/125894892
版权

直接读/data/misc/ethernet/ipconfig.txt文件显示乱码

C语言实现方式

使用如下方式读取ipconfig.txt

代码结构

Android.mk
data.c
data.h
ipconfig.c
ipconfig.h
main.c

Android.mk

LOCAL_PATH:= $(call my-dir)


include $(CLEAR_VARS)

LOCAL_SRC_FILES:= main.c data.c ipconfig.c

#LOCAL_C_INCLUDES := $(LOCAL_PATH)/include

LOCAL_CFLAGS += -Wall -Wno-unused-parameter -Wextra
# -Wno-implicit-function-declaration
LOCAL_SHARED_LIBRARIES := \
    libcutils \
    liblog \
    libandroidfw \
    libutils \
    libbinder \
    libjsoncpp

LOCAL_MODULE := ipcnfigstore

include $(BUILD_EXECUTABLE)

data.c

#define _GNU_SOURCE

#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>


#include "data.h"

uint16_t convertBigEndianUInt16(uint16_t value)
{
	union { uint16_t value; unsigned char data[2]; } aux = { 0x4142 };

	if (aux.data[0] == 0x41)
	{
		return value;
	}

	aux.data[0] = (value >> 8) & 0xff;
	aux.data[1] = value & 0xff;

	return aux.value;
}

uint32_t convertBigEndianUInt32(uint32_t value)
{
	union { uint32_t value; unsigned char data[4]; } aux = { 0x41424344 };

	if (aux.data[0] == 0x41)
	{
		return value;
	}

	aux.data[0] = (value >> 24) & 0xff;
	aux.data[1] = (value >> 16) & 0xff;
	aux.data[2] = (value >> 8) & 0xff;
	aux.data[3] = value & 0xff;

	return aux.value;
}

bool readPackedLink(FILE *stream, struct IPConfigLink *link)
{
	char **address = &link->address;
	uint32_t *prefix = &link->prefix;

	if (!readPackedString(stream, address))
	{
		return false;
	}

	if (!readPackedUInt32(stream, prefix))
	{
		return false;
	}

	return true;
}

bool readPackedRoute(FILE *stream, struct IPConfigRoute *route)
{
	char **destinationAddress = &route->destination.address;
	uint32_t *destinationPrefix = &route->destination.prefix;
	char **nextHop = &route->nextHop;

	uint32_t haveDestination = 0;
	uint32_t haveNextHop = 0;

	if (!readPackedUInt32(stream, &haveDestination))
	{
		return false;
	}

	if (haveDestination)
	{
		if (!readPackedString(stream, destinationAddress))
		{
			return false;
		}

		if (!readPackedUInt32(stream, destinationPrefix))
		{
			return false;
		}
	}

	if (!readPackedUInt32(stream, &haveNextHop))
	{
		return false;
	}

	if (haveNextHop)
	{
		if (!readPackedString(stream, nextHop))
		{
			return false;
		}
	}

	return true;
}

bool readPackedString(FILE *stream, char **string)
{
	uint16_t length = 0;

	if (!readPackedUInt16(stream, &length))
	{
		return false;
	}

	while (length == 0)
	{
		if (fseek(stream, sizeof(uint16_t), SEEK_CUR) == -1)
		{
			return false;
		}

		if (!readPackedUInt16(stream, &length))
		{
			return false;
		}
	}

	*string = calloc(1, length + 1);

	if (!*string)
	{
		return false;
	}

	if (fread(*string, length, 1, stream) != 1)
	{
		if (!feof(stream))
		{
			free(*string);
			return false;
		}
	}

	return true;
}

bool readPackedUInt16(FILE *stream, uint16_t *value)
{
	uint16_t buffer = 0; 

	if (fread(&buffer, sizeof buffer, 1, stream) != 1)
	{
		return false;
	}

	*value = convertBigEndianUInt16(buffer);
	return true;
}

bool readPackedUInt32(FILE *stream, uint32_t *value)
{
	uint32_t buffer = 0; 

	if (fread(&buffer, sizeof buffer, 1, stream) != 1)
	{
		return false;
	}

	*value = convertBigEndianUInt32(buffer);
	return true;
}

bool writePackedRoute(struct IPConfigRoute *route, FILE *stream)
{
	struct IPConfigLink *destination = &route->destination;

	if (destination->address && destination->prefix)
	{
		if (!writePackedUInt32(1, stream))
		{
			return false;
		}

		if (!writePackedString(destination->address, stream))
		{
			return false;
		}

		if (!writePackedUInt32(destination->prefix, stream))
		{
			return false;
		}
	}

	else
	{
		if (!writePackedUInt32(0, stream))
		{
			return false;
		}
	}

	if (route->nextHop)
	{
		if (!writePackedUInt32(1, stream))
		{
			return false;
		}

		if (!writePackedString(route->nextHop, stream))
		{
			return false;
		}
	}

	else
	{
		if (!writePackedUInt32(0, stream))
		{
			return false;
		}
	}

	return true;
}

bool writePackedLink(struct IPConfigLink *link, FILE *stream)
{
	if (!writePackedString(link->address, stream))
	{
		return false;
	}

	if (!writePackedUInt32(link->prefix, stream))
	{
		return false;
	}

	return true;
}

bool writePackedString(char *string, FILE *stream)
{
	size_t stringLength = strlen(string);

	if (!writePackedUInt16(stringLength, stream))
	{
		return false;
	}

	return fwrite(string, stringLength, 1, stream) == 1;
}

bool writePackedUInt16(uint16_t value, FILE *stream)
{
	uint16_t buffer = convertBigEndianUInt16(value);
	return fwrite(&buffer, sizeof buffer, 1, stream) == 1;
}

bool writePackedUInt32(uint32_t value, FILE *stream)
{
	uint32_t buffer = convertBigEndianUInt32(value);
	return fwrite(&buffer, sizeof buffer, 1, stream) == 1;
}

bool readUnpackedLine(FILE *stream, char **line)
{
	char *cursor = NULL;

	*line = calloc(1, BUFSIZ);

	if (!*line)
	{
		return false;
	}
	
	cursor = *line;

	while (cursor - *line < BUFSIZ)
	{
		int character = fgetc(stream);

		if (character == EOF || character == '\n')
		{
			break;
		}

		*cursor++ = character;
	}

	return true;
}

bool parseUnpackedPair(char *line, char **key, char **value)
{
	char *next = strchr(line, ':');

	if (!next)
	{
		return false;
	}

	*key = strndup(line, next - line);

	if (!*key)
	{
		return false;
	}

	while (*++next && isspace(*next));
	*value = strdup(next);

	if (!*value)
	{
		free(*key);
		return false;
	}

	return true;
}

bool parseUnpackedRoute(char *string, struct IPConfigRoute *route)
{
	char *next = strchr(string, ' ');

	if (next)
	{
		*next = 0;

		if (!parseUnpackedLink(string, &route->destination))
		{
			return false;
		}

		string = ++next;
	}

	route->nextHop = strdup(string);

	if (!route->nextHop)
	{
		return false;
	}

	return true;
}

bool parseUnpackedLink(char *string, struct IPConfigLink *link)
{
	char *next = strchr(string, '/');

	if (!next)
	{
		return false;
	}

	link->address = strndup(string, next - string);

	if (!link->address)
	{
		return false;
	}

	if (!parseUnpackedUInt32(++next, &link->prefix))
	{
		free(link->address);
		return false;
	}

	return true;
}

bool parseUnpackedUInt32(char *string, uint32_t *integer)
{
	char *terminator = NULL;
	unsigned long value = strtoul(string, &terminator, 10);

	if (*terminator)
	{
		return false;
	}

	*integer = value % UINT32_MAX;
	return true;
}


data.h

#ifndef IPCONFIG_DATA_H
#define IPCONFIG_DATA_H

#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>

#include "ipconfig.h"

uint16_t convertBigEndianUInt16(uint16_t value);
uint32_t convertBigEndianUInt32(uint32_t value);

bool readPackedRoute(FILE *stream, struct IPConfigRoute *route);
bool readPackedLink(FILE *stream, struct IPConfigLink *link);
bool readPackedString(FILE *stream, char **string);
bool readPackedUInt16(FILE *stream, uint16_t *value);
bool readPackedUInt32(FILE *stream, uint32_t *value);

bool writePackedRoute(struct IPConfigRoute *route, FILE *stream);
bool writePackedLink(struct IPConfigLink *link, FILE *stream);
bool writePackedString(char *string, FILE *stream);
bool writePackedUInt16(uint16_t value, FILE *stream);
bool writePackedUInt32(uint32_t value, FILE *stream);

bool readUnpackedLine(FILE *stream, char **line);
bool parseUnpackedPair(char *line, char **key, char **value);
bool parseUnpackedRoute(char *string, struct IPConfigRoute *route);
bool parseUnpackedLink(char *string, struct IPConfigLink *link);
bool parseUnpackedUInt32(char *string, uint32_t *integer);

#endif


ipconfig.c

#define _DEFAULT_SOURCE

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>

#include <unistd.h>
#include "data.h"
#include "ipconfig.h"
#include "error.h"

#define calculateElementCount(array) (sizeof array / sizeof *array)

static const uint32_t IPConfigFileMinimumVersion = 1;
static const uint32_t IPConfigFileMaximumVersion = 3;

static char *IPConfigTerminatorKey = "eos";

static struct IPConfigAttributeKey IPConfigVersion1AttributeKeys[] =
{
	{"id", IntegerIPConfigAttributeType},
	{"ipAssignment", StringIPConfigAttributeType},
	{"linkAddress", LinkIPConfigAttributeType},
	{"gateway", StringIPConfigAttributeType},
	{"dns", StringIPConfigAttributeType},
	{"proxySettings", StringIPConfigAttributeType},
	{"proxyHost", StringIPConfigAttributeType},
	{"proxyPort", IntegerIPConfigAttributeType},
	{"proxyPac", StringIPConfigAttributeType},
	{"exclusionList", StringIPConfigAttributeType},
	{"eos", TerminalIPConfigAttributeType}
};

static size_t IPConfigVersion1AttributeKeyCount = 
	calculateElementCount(IPConfigVersion1AttributeKeys);

static struct IPConfigAttributeKey IPConfigVersion2AttributeKeys[] =
{
	{"id", IntegerIPConfigAttributeType},
	{"ipAssignment", StringIPConfigAttributeType},
	{"linkAddress", LinkIPConfigAttributeType},
	{"gateway", RouteIPConfigAttributeType},
	{"dns", StringIPConfigAttributeType},
	{"proxySettings", StringIPConfigAttributeType},
	{"proxyHost", StringIPConfigAttributeType},
	{"proxyPort", IntegerIPConfigAttributeType},
	{"proxyPac", StringIPConfigAttributeType},
	{"exclusionList", StringIPConfigAttributeType},
	{"eos", TerminalIPConfigAttributeType}
};

static size_t IPConfigVersion2AttributeKeyCount = 
	calculateElementCount(IPConfigVersion2AttributeKeys);

static struct IPConfigAttributeKey IPConfigVersion3AttributeKeys[] =
{
	{"id", StringIPConfigAttributeType},
	{"ipAssignment", StringIPConfigAttributeType},
	{"linkAddress", LinkIPConfigAttributeType},
	{"gateway", RouteIPConfigAttributeType},
	{"dns", StringIPConfigAttributeType},
	{"proxySettings", StringIPConfigAttributeType},
	{"proxyHost", StringIPConfigAttributeType},
	{"proxyPort", IntegerIPConfigAttributeType},
	{"proxyPac", StringIPConfigAttributeType},
	{"exclusionList", StringIPConfigAttributeType},
	{"eos", TerminalIPConfigAttributeType}
};

static size_t IPConfigVersion3AttributeKeyCount = 
	calculateElementCount(IPConfigVersion3AttributeKeys);

static enum IPConfigAttributeType getAttributeType(uint32_t version, char *key)
{
	size_t keyLength = strlen(key);

	struct IPConfigAttributeKey *keys = NULL;
	size_t count = 0;

	switch (version)
	{
		case 1:
			keys = IPConfigVersion1AttributeKeys;
			count = IPConfigVersion1AttributeKeyCount;
			break;

		case 2:
			keys = IPConfigVersion2AttributeKeys;
			count = IPConfigVersion2AttributeKeyCount;
			break;

		case 3:
			keys = IPConfigVersion3AttributeKeys;
			count = IPConfigVersion3AttributeKeyCount;
			break;

		default:
			break;
	};

	for (size_t index = 0; index < count; index++)
	{
		char *candidate = keys[index].key;
		size_t maximumLength = strlen(candidate);

		if (keyLength > maximumLength)
		{
			maximumLength = keyLength;
		}

		if (!strncmp(candidate, key, maximumLength))
		{
			return keys[index].type;
		}
	}

	return InvalidIPConfigAttributeType;
}

static void appendAttribute(struct IPConfigAttribute *attribute,
                            struct IPConfig *config)
{
	if (!config->attributes)
	{
		config->attributes = attribute;
	}

	else
	{
		struct IPConfigAttribute *previous = config->attributes;

		while (previous->next)
		{
			previous = previous->next;
		}

		previous->next = attribute;
	}
}

bool readPackedIPConfig(FILE *stream, struct IPConfig *config)
{

	if (!readPackedUInt32(stream, &config->version))
	{
		printError("failed to read file version");
		return NULL;
	}
	
	if (config->version < IPConfigFileMinimumVersion ||
	    config->version > IPConfigFileMaximumVersion)
	{
		printError("unrecognized file version");
		return NULL;
	}

	while (!feof(stream))
	{
		struct IPConfigAttribute *attribute = NULL;
		attribute = calloc(1, sizeof(struct IPConfigAttribute));

		if (!attribute)
		{
			printLibraryError("calloc");
			deinitializeIPConfig(config);
			return NULL;
		}

		appendAttribute(attribute, config);

		if (!readPackedString(stream, &attribute->key))
		{
			printError("failed to read attribute key");
			deinitializeIPConfig(config);
			return NULL;
		}

		attribute->type = getAttributeType(config->version,
		                                   attribute->key);

		if (attribute->type == InvalidIPConfigAttributeType)
		{
			printError("unrecognized attribute key");
			deinitializeIPConfig(config);
			return NULL;
		}

		else if (attribute->type == TerminalIPConfigAttributeType)
		{
			break;
		}

		else if (attribute->type == IntegerIPConfigAttributeType)
		{
			uint32_t *integer = &attribute->value.integer;

			if (!readPackedUInt32(stream, integer))
			{
				printError("failed to read integer");
				deinitializeIPConfig(config);
				return NULL;
			}
		}

		else if (attribute->type == StringIPConfigAttributeType)
		{
			char **string = &attribute->value.string;

			if (!readPackedString(stream, string))
			{
				printError("failed to read string");
				deinitializeIPConfig(config);
				return NULL;
			}
		}

		else if (attribute->type == LinkIPConfigAttributeType)
		{
			if (!readPackedLink(stream, &attribute->value.link))
			{
				printError("failed to read link");
				deinitializeIPConfig(config);
				return NULL;
			}
		}

		else if (attribute->type == RouteIPConfigAttributeType)
		{
			if (!readPackedRoute(stream, &attribute->value.route))
			{
				printError("failed to read route");
				deinitializeIPConfig(config);
				return NULL;
			}
		}
	}

	return config;
}

void deinitializeIPConfig(struct IPConfig *config)
{
	struct IPConfigAttribute *next = NULL;
	struct IPConfigAttribute *attribute = config->attributes;

	while (attribute)
	{
		union IPConfigValue *value = &attribute->value;

		if (attribute->type == StringIPConfigAttributeType)
		{
			free(value->string);
		}

		else if (attribute->type == LinkIPConfigAttributeType)
		{
			free(value->link.address);
		}

		else if (attribute->type == RouteIPConfigAttributeType)
		{
			if (value->route.destination.address)
			{
				free(value->route.destination.address);
			}

			if (value->route.nextHop)
			{
				free(value->route.nextHop);
			}
		}

		next = attribute->next;	
		free(attribute->key);
		free(attribute);
		attribute = next;
	}
}

bool writePackedIPConfig(struct IPConfig *config, FILE *stream)
{
	bool terminated = false;
	struct IPConfigAttribute *attribute = config->attributes;

	if (!writePackedUInt32(config->version, stream))
	{
		printError("failed to write file version");
		return false;
	}

	while (attribute)
	{
		union IPConfigValue *value = &attribute->value;

		if (!writePackedString(attribute->key, stream))
		{
			printError("failed to write key");
			return false;
		}

		if (attribute->type == TerminalIPConfigAttributeType)
		{
			terminated = true;
			break;
		}

		else if (attribute->type == IntegerIPConfigAttributeType)
		{
			if (!writePackedUInt32(value->integer, stream))
			{
				printError("failed to write integer");
				return false;
			}
		}

		else if (attribute->type == StringIPConfigAttributeType)
		{
			if (!writePackedString(value->string, stream))
			{
				printError("failed to write string");
				return false;
			}
		}

		else if (attribute->type == LinkIPConfigAttributeType)
		{
			if (!writePackedLink(&value->link, stream))
			{
				printError("failed to write link");
				return false;
			}
		}

		else if (attribute->type == RouteIPConfigAttributeType)
		{
			if (!writePackedRoute(&value->route, stream))
			{
				printError("failed to write route");
				return false;
			}
		}

		attribute = attribute->next;
	}

	if (!terminated)
	{
		if (!writePackedString(IPConfigTerminatorKey, stream))
		{
			printError("failed to write terminator");
			return false;
		}
	}

	return true;
}

bool writeUnpackedIPConfig(struct IPConfig *config, FILE *stream)
{
	struct IPConfigAttribute *attribute = config->attributes;

	while (attribute)
	{
		if (attribute->type == IntegerIPConfigAttributeType)
		{
			fprintf(stream, "%s: %" PRIu32 "\n",
			                attribute->key,
			                attribute->value.integer);
		}

		else if (attribute->type == StringIPConfigAttributeType)
		{
			fprintf(stream, "%s: %s\n",
			                attribute->key,
			                attribute->value.string);
		}

		else if (attribute->type == LinkIPConfigAttributeType)
		{
			struct IPConfigLink *link = &attribute->value.link;

			fprintf(stream, "%s: %s/%" PRIu32 "\n",
			                attribute->key,
			                link->address,
			                link->prefix);
		}

		else if (attribute->type == RouteIPConfigAttributeType)
		{
			struct IPConfigRoute *route = &attribute->value.route;
			struct IPConfigLink *destination = &route->destination;

			if (destination->address && destination->prefix)
			{
				fprintf(stream, "%s: %s/%" PRIu32 " %s\n",
			                        attribute->key,
			                        destination->address,
			                        destination->prefix,
			                        route->nextHop);
			}

			else
			{
				fprintf(stream, "%s: %s\n",
			                        attribute->key,
			                        route->nextHop);
			}
		}

		attribute = attribute->next;
	}

	return true;
}

bool readUnpackedIPConfig(FILE *stream, struct IPConfig *config)
{
	if (config->version < IPConfigFileMinimumVersion ||
	    config->version > IPConfigFileMaximumVersion)
	{
		printError("unrecognized file version");
		return false;
	}

	while (!feof(stream))
	{
		char *line = NULL;
		char *value = NULL;

		struct IPConfigAttribute *attribute = NULL;
		attribute = calloc(1, sizeof(struct IPConfigAttribute));

		if (!attribute)
		{
			printLibraryError("calloc");
			deinitializeIPConfig(config);
			return false;
		}

		appendAttribute(attribute, config);

		if (!readUnpackedLine(stream, &line))
		{
			printError("failed to read line");
			deinitializeIPConfig(config);
			return false;
		}
	
		if (strlen(line) == 0)
		{
			free(line);

			if (feof(stream))
			{
				attribute->key = strdup(IPConfigTerminatorKey);
				break;
			}

			continue;
		}

		if (!parseUnpackedPair(line, &attribute->key, &value))
		{
			printError("failed to read pair");
			deinitializeIPConfig(config);
			free(line);
			return false;
		}

		free(line);
		attribute->type = getAttributeType(config->version,
		                                   attribute->key);

		if (!attribute->type)
		{
			printError("unrecognized attribute type");
			deinitializeIPConfig(config);
			free(value);
			return false;
		}

		else if (attribute->type == IntegerIPConfigAttributeType)
		{
			uint32_t *integer = &attribute->value.integer;

			if (!parseUnpackedUInt32(value, integer))
			{
				printError("failed to read integer");
				deinitializeIPConfig(config);
				free(value);
				return false;
			}

			free(value);
		}

		else if (attribute->type == StringIPConfigAttributeType)
		{
			attribute->value.string = value;
		}

		else if (attribute->type == LinkIPConfigAttributeType)
		{
			if (!parseUnpackedLink(value, &attribute->value.link))
			{
				printError("failed to read link");
				deinitializeIPConfig(config);
				free(value);
				return false;
			}

			free(value);
		}

		else if (attribute->type == RouteIPConfigAttributeType)
		{
			struct IPConfigRoute *route = &attribute->value.route;

			if (!parseUnpackedRoute(value, route))
			{
				printError("failed to read route");
				deinitializeIPConfig(config);
				free(value);
				return false;
			}

			free(value);
		}
	}

	return true;
}

void printConfig(struct IPConfig *config) {
    struct IPConfigAttribute *attribute = config->attributes;
    while (attribute)
    {
		if (attribute->type == RouteIPConfigAttributeType) {
        struct IPConfigRoute *route = &attribute->value.route;
		struct IPConfigLink *destination = &route->destination;
        if (destination->address && destination->prefix) {
            printf("%s: %s/%" PRIu32 " %s\n",attribute->key,destination->address,destination->prefix,route->nextHop);
	       }
        if (strcmp(attribute->key,"gateway") == 0) {
           strcpy(static_cfg[2],route->nextHop);
		   }
		}
	    if (strcmp(attribute->key,"linkAddress") == 0) {
		    struct IPConfigLink *link = &attribute->value.link;
            strcpy(static_cfg[0],attribute->value.string);
		    ipv4_prefixlen2str(link->prefix,static_cfg[1]);
			strcpy(static_cfg[5],static_cfg[0]);
			char str[25];
			sprintf(str,"/%d",link->prefix);
			strcat(static_cfg[5],str);
		} else if (strcmp(attribute->key,"dns") == 0) {
		    if (strlen(static_cfg[3]) != 0) {
            strcpy(static_cfg[4],attribute->value.string);
		} else {
            strcpy(static_cfg[3],attribute->value.string);
		}
	}
        //printf("%d,%s:%s --> ", attribute->type, attribute->key, attribute->value.string);
        attribute = attribute->next;
    }
    //printf("\n");
}

bool genPackedDHCPIPConfig(struct IPConfig *config) {
    if (config->version < IPConfigFileMinimumVersion ||
        config->version > IPConfigFileMaximumVersion)
    {
        printError("unrecognized file version");
        return false;
    }

    char static_cfg[3][40] = {
            "ipAssignment: DHCP",
            "proxySettings: NONE",
            "id: eth0"
    };

    for (int i = 0; i < 3; i++ ) {
//        printf("%s\n", static_cfg[i]);
//        char *line = NULL;
        char *value = NULL;

        struct IPConfigAttribute *attribute = NULL;
        attribute = calloc(1, sizeof(struct IPConfigAttribute));

        if (!attribute)
        {
            printLibraryError("calloc");
            deinitializeIPConfig(config);
            return false;
        }

        appendAttribute(attribute, config);

        if (!parseUnpackedPair(static_cfg[i], &attribute->key, &value))
        {
            printError("failed to read pair");
            deinitializeIPConfig(config);
            free(static_cfg[i]);
            return false;
        }

        attribute->type = getAttributeType(config->version,
                                           attribute->key);

        if (!attribute->type)
        {
            printError("unrecognized attribute type");
            deinitializeIPConfig(config);
            free(value);
            return false;
        }

        else if (attribute->type == IntegerIPConfigAttributeType)
        {
            uint32_t *integer = &attribute->value.integer;

            if (!parseUnpackedUInt32(value, integer))
            {
                printError("failed to read integer");
                deinitializeIPConfig(config);
                free(value);
                return false;
            }

            free(value);
        }

        else if (attribute->type == StringIPConfigAttributeType)
        {
            attribute->value.string = value;
        }

        else if (attribute->type == LinkIPConfigAttributeType)
        {
            if (!parseUnpackedLink(value, &attribute->value.link))
            {
                printError("failed to read link");
                deinitializeIPConfig(config);
                free(value);
                return false;
            }

            free(value);
        }

        else if (attribute->type == RouteIPConfigAttributeType)
        {
            struct IPConfigRoute *route = &attribute->value.route;

            if (!parseUnpackedRoute(value, route))
            {
                printError("failed to read route");
                deinitializeIPConfig(config);
                free(value);
                return false;
            }

            free(value);
        }
    }
    return true;
}

bool genPackedIPConfig(struct IPConfig *config, char *linkAddress, char *gw, char *dns1, char *dns2)
{
    if (config->version < IPConfigFileMinimumVersion ||
        config->version > IPConfigFileMaximumVersion)
    {
        printError("unrecognized file version");
        return false;
    }

    char static_cfg[7][100] = {
            "ipAssignment: STATIC",
            "linkAddress: ",
            "gateway: ",
            "dns: ",
            "dns: ",
            "proxySettings: NONE",
            "id: eth0"
    };
    strcat(static_cfg[1], linkAddress);
    strcat(static_cfg[2], gw);
    strcat(static_cfg[3], dns1);
    strcat(static_cfg[4], dns2);

    for (int i = 0; i < 7; i++ ) {
//        printf("%s\n", static_cfg[i]);
//        char *line = NULL;
        char *value = NULL;

        struct IPConfigAttribute *attribute = NULL;
        attribute = calloc(1, sizeof(struct IPConfigAttribute));

        if (!attribute)
        {
            printLibraryError("calloc");
            deinitializeIPConfig(config);
            return false;
        }

        appendAttribute(attribute, config);

        if (!parseUnpackedPair(static_cfg[i], &attribute->key, &value))
        {
            printError("failed to read pair");
            deinitializeIPConfig(config);
            free(static_cfg[i]);
            return false;
        }

        attribute->type = getAttributeType(config->version,
                                           attribute->key);

        if (!attribute->type)
        {
            printError("unrecognized attribute type");
            deinitializeIPConfig(config);
            free(value);
            return false;
        }

        else if (attribute->type == IntegerIPConfigAttributeType)
        {
            uint32_t *integer = &attribute->value.integer;

            if (!parseUnpackedUInt32(value, integer))
            {
                printError("failed to read integer");
                deinitializeIPConfig(config);
                free(value);
                return false;
            }

            free(value);
        }

        else if (attribute->type == StringIPConfigAttributeType)
        {
            attribute->value.string = value;
        }

        else if (attribute->type == LinkIPConfigAttributeType)
        {

            if (!parseUnpackedLink(value, &attribute->value.link))
            {
                printError("failed to read link");
                deinitializeIPConfig(config);
                free(value);
                return false;
            }

            free(value);
        }

        else if (attribute->type == RouteIPConfigAttributeType)
        {
            struct IPConfigRoute *route = &attribute->value.route;

            if (!parseUnpackedRoute(value, route))
            {
                printError("failed to read route");
                deinitializeIPConfig(config);
                free(value);
                return false;
            }

            free(value);
        }
    }
    return true;
}

int ipv4_prefixlen2str(int prefixlen, char* ip_str)
{
    //char tmp[16] = {0};
    //char* p = tmp;
    unsigned int ip_num = 0;
 
    if (ip_str == NULL) return -1;
    if (prefixlen > 32) return -1;
 
    // fast...
    if (prefixlen == 8) strcpy(ip_str, "255.0.0.0");
    if (prefixlen == 16) strcpy(ip_str, "255.255.0.0");
    if (prefixlen == 24) strcpy(ip_str, "255.255.255.0");
    if (prefixlen == 32) strcpy(ip_str, "255.255.255.255");
 
    // just in case
    for (int i = prefixlen, j = 31; i > 0; i--, j--)
    {
        //unsigned int tmp = (1<<j);
        //printf("%d tmp: %08x\n", i, tmp);
        ip_num += (1<<j);
    }
    //printf("ip_num: %08x\n", ip_num);
    sprintf(ip_str, "%u.%u.%u.%u", (ip_num>>24)&0xff, (ip_num>>16)&0xff, (ip_num>>8)&0xff, ip_num&0xff);
    return 0;
}

/*
int ipv4_str2prefixlen(const char* ip_str)
{
    int ret = 0;
    unsigned int ip_num = 0;
    unsigned char c1,c2,c3,c4;
    int cnt = 0;

    ret = sscanf(ip_str, "%hhu.%hhu.%hhu.%hhu", &c1, &c2, &c3, &c4);
    ip_num = c1<<24 | c2<<16 | c3<<8 | c4;

    // fast...
    if (ip_num == 0xffffffff) return 32;
    if (ip_num == 0xffffff00) return 24;
    if (ip_num == 0xffff0000) return 16;
    if (ip_num == 0xff000000) return 6;
    // just in case
    for (int i = 0; i < 32; i++)
    {
        //unsigned int tmp = (ip_num<<i);
        //printf("%d tmp: %x\n", i+1, tmp);
        if ((ip_num<<i) & 0x80000000)
            cnt++;
        else
            break;
    }
    //printf("cnt: %d\n", cnt);
    return cnt;
}
*/


ipconfig.h

#ifndef IPCONFIG_H
#define IPCONFIG_H

#include <stdbool.h>
#include <inttypes.h>

enum IPConfigAttributeType
{
	InvalidIPConfigAttributeType = -1,
	TerminalIPConfigAttributeType = 0,
	IntegerIPConfigAttributeType = 1,
	StringIPConfigAttributeType = 2,
	LinkIPConfigAttributeType = 3,
	RouteIPConfigAttributeType = 4
};

struct IPConfigAttributeKey
{
	char *key;
	enum IPConfigAttributeType type;
};

struct IPConfigLink
{
	char *address;
	uint32_t prefix;
};

struct IPConfigRoute
{
	struct IPConfigLink destination;
	char *nextHop;
};

union IPConfigValue
{
	uint32_t integer;
	char *string;
	struct IPConfigLink link;
	struct IPConfigRoute route;
};

struct IPConfigAttribute
{
	enum IPConfigAttributeType type;
	char *key;
	union IPConfigValue value;
	struct IPConfigAttribute *next;
};

struct IPConfig
{
	uint32_t version;
	struct IPConfigAttribute *attributes;
};

extern struct IPConfig config;

// extern char static_cfg[4][100] = {
//         "",   //ip mask
//         "",   //gateway
//         "",   //dns1
//         ""    //dns2
// };

extern char static_cfg[6][100];

bool readPackedIPConfig(FILE *stream, struct IPConfig *config);
bool readUnpackedIPConfig(FILE *stream, struct IPConfig *config);
bool writePackedIPConfig(struct IPConfig *config, FILE *stream);
bool writeUnpackedIPConfig(struct IPConfig *config, FILE *stream);

void deinitializeIPConfig(struct IPConfig *config);

int writeipconfig(int argc, char *argv[]);
void printConfig(struct IPConfig *config);
bool genPackedIPConfig(struct IPConfig *config, char *linkAddress, char *gw, char *dns1, char *dns2);
bool genPackedDHCPIPConfig(struct IPConfig *config);

int ipv4_prefixlen2str(int prefixlen, char* ip_str);
int ipv4_str2prefixlen(const char* ip_str);


#endif


main.c

#define _XOPEN_SOURCE
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#include "ipconfig.h"
#include "error.h"

static void usage(FILE *stream)
{
	fprintf(stream, "usage: ipconfigstore OPTION\n");
	fprintf(stream, "\n");
	fprintf(stream, "Options:\n");
	fprintf(stream, "  -p VERSION    Pack IP configuration\n");
	fprintf(stream, "  -u            Unpack IP configuration\n");
	fprintf(stream, "\n");
}

int main(int argc, char *argv[])
{
	int option = 0;
	struct IPConfig config = {0};

	option = getopt(argc, argv, "hp:u");

	if (option == 'h')
	{
		usage(stdout);
		return EXIT_SUCCESS;
	}

	else if (option == 'p')
	{
		config.version = *optarg - 0x30;

		if (!readUnpackedIPConfig(stdin, &config))
		{
			return EXIT_FAILURE;
		}

		if (!writePackedIPConfig(&config, stdout))
		{
			return EXIT_FAILURE;
		}

		deinitializeIPConfig(&config);
	}

	else if (option == 'u')
	{
        FILE *pFile;
        pFile = fopen("/data/misc/ethernet/ipconfig.txt", "r");
        if(pFile == NULL)//文件指针为空时的措施
        {
            printf("can not open the file");
            fclose(pFile);
            return 0;
        }
		if (!readPackedIPConfig(pFile, &config))
		{
			return EXIT_FAILURE;
		}

		if (!writeUnpackedIPConfig(&config, stdout))
		{
			return EXIT_FAILURE;
		}

		deinitializeIPConfig(&config);
        fclose(pFile);
	}

	else
	{
		usage(stderr);
		return EXIT_FAILURE;
	}
	
	return EXIT_SUCCESS;
}

编译完将生成的ipcnfigstore文件push到 /data目录下给可执行权限

 执行结果截图如下（显示结果就是/data/misc/ethernet/ipconfig.txt内容）

源码GitHub地址：

git clone git@github.com:hejiangzhou1/readIpconfig.git

1074412099
关注
专栏目录
ipconfig.txt
08-06
android系统 eth0 有线网络配置，/data/misc/ethernet/ipconfig.txt
Android终端通过adb 配置静态IP和DNS
热门推荐
u013463707的专栏
10-26 1万+
有时我们需要使用命令行来配置eth0的IP信息，这在linux系统是非常简单的，网上也有很多资料。但是在Android系统，就非常困难，因为Android精简掉了很多linux命令，而且配置的方法也和linux有区别，甚至不同Android版本，不同平台方法也不一样。 那如何解决这个问题呢？还是得借助busybox,busybox集成了很多linux的命令，只需要push这一个命令就可以解决，确实方便不少。下面说说具体方法。 1.ifconfig 查看物理网卡名称，通常是et...
Android 13 有线以太网静态ip保存逻辑梳理分析
以后会多把工作中总结的知识、问题处理思路和方法通过博客分享出来,欢迎大家关注和共同探讨!
04-17 1777
这个类主要就是用来配置静态IP的，这个类之前也是在frameworks/base/core/java/android/net/路径下，12里面也移到了packages/modules/Connectivity/framework/src/android/net/下。，所以如果之前只在11上面适配过，那么对于12来说，适配还是需要花费一点功夫，具体的差异在之后的部分会记录，但是12与13的有线网络差异就较小了，并且看起来，13的以太网接口以及逻辑比12来说更为完善。源码环境：高通Android 13。
ipconfig命令详解.txt
11-11
1.具体功能p 该命令用于显示所有当前的TCP/IP网络配置值、刷新动态主机配置协议(DHCP)和域名系统(DNS)设置。使用不带参数的IPCONFIG可以显示所有适配器的IP地址、子网掩码、默认网关。p 2.语法详解p ipconfigp[/all]p[/renewp[adapter]p[/releasep[adapter]p[/flushdns]p[/displaydns]p[/registerdns]p[/showclassidpadapter]p[/setclassidpadapterp[classID]p 3.参数说明p /allp显示所有适配器的完整TCP/IP配置信息。在没有该参数的情况下IPCONFIG只显示IP地址、子网掩码和各个适配器的默认网关值。适配器可以代表物理接口(例如安装的网络适配器)或逻辑接口(例如拨号连接)。p /renewp[adapter]p更新所有适配器(如果未指定适配器)，或特定适配器(如果包含了adapter参数)的DHCP配置。该参数仅在具有配置为自动获取IP地址的网卡的计算机上可用。要指定适配器名称，请键入使用不带参数的IPCONFIG命
creo 计算机配置,config配置文件乱码,creo配置文件config
weixin_42114046的博客
07-08 2209
近期在windows 操作系统中有用户反应遇到了加载配置文件时出错 对路径C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\CONFIG\machine.config的访问的故障现象，该如何进行修复呢？本文中winwin7给大家介绍下系统中遇到：加载配置文件时出错 对路径C:\WINDOWS\Microsoft.NET\Framework\v2.0.507...
Andoird - 解决读取txt文件中文乱码问题
灯塔ADA的专栏
05-13 1万+
    从SDCard保存的txt文件读取中文到android系统中会出现乱码问题，如何解决这个乱码问题，网上有不少解答方法，譬如说利用 String temp1 = EncodingUtils.getString(strLine.getBytes(),"GB2312"); 但并非对所有的情况都适用，解决乱码问题首先要明白为什么会乱码。究其原因，是因为txt文件在win系统上保存时默认为ANSI格式，而android目前只支持UTF-8编码，因此将txt文件的中文读入android系统中会产生乱码。也有
配置文件出现乱码
lilianplayer_163的专栏
01-16 2248
严重: Parse Fatal Error at line 51 column 50: Invalid byte 3 of 3-byte UTF-8 sequence.org.xml.sax.SAXParseException: Invalid byte 3 of 3-byte UTF-8 sequence. at com.sun.org.apache.xerces.internal.util.E
关于在git bash下使用ping ipconfig出现白框框乱码的情况
weixin_41357783的博客
08-12 1182
关于在gitbash命令行下使用ping命令出现框框乱码的问题关注CSDN很久了，在这里自己的很多问题都得到了解决，真心感谢每一位技术大牛。在这里也将自己遇到的一些问题的解决方法写出来，希望能够帮助到像自己一样的小白。 关注CSDN很久了，在这里自己的很多问题都得到了解决，真心感谢每一位技术大牛。在这里也将自己遇到的一些问题的解决方法写出来，希望能够帮助到像自己一样的小白。 最近在使用ping命令...
android studio与ideal后台进行交互_Android通过Web与后台数据库交互
weixin_39850697的博客
02-04 3806
2021.1.27 更新 已更新新版本博客，更新内容与原文章相比有点多，因此新开了一篇博客，链接在下方：氷泠：Android+Java Web+MySQL实现登录注册​zhuanlan.zhihu.com1 背景开发一个App与后台数据库交互，基于MySQL+原生JDBC+Tomcat，没有使用DBUtils或JDBC框架，纯粹底层JDBC实现。这几天踩了很多坑，说得夸张点真是踩到没有知觉，希望能...
Android通过Web与后台数据库交互
氷泠
10-13 1万+
目录 1.背景 2.开发环境 3.相关资源 4.后端部分 5.前端部分 6.注意事项 7.失败经历 1.背景 开发一个app与后台数据库交互,基于mysql+jdbc,没有使用DBUtils或jdbc框架,纯粹底层jdbc实现. 2.开发环境 系统 : win10 IDE : Android Studio 3.5.1,IntelliJ IDEA 2019.02 DBMS : Mysql 8.0....
100天精通Andriod逆向——第4天：各种抓包工具学习
Amo Xiang的博客
08-10 5605
在网页中，我们可以借助浏览器开发者工具中的 Network 面板看到网页中产生的所有网络请求和响应内容，然而 App 怎么办呢？要想拦截 App 中的网络请求，就得用到抓包工具了，例如：Charles、Fiddler、mitmproxy 等，我们可以通过这些工具拦截 App 和 API 通信的请求内容和响应内容，如果能从中找到一定的规律，就可以用程序直接构造请求来模拟 API 的请求，从而完成数据爬取......
Qt开发经验总结
草上爬的博客
12-02 8611
增加了很多轮子，同时原有模块拆分的也更细致，估计为了方便拓展个管理。把一些过度封装的东西移除了（比如同样的功能有多个函数），保证了只有一个函数执行该功能。把一些Qt5中兼容Qt4的方法废弃了，必须用Qt5中对应的新的函数。跟随时代脚步，增加了不少新特性以满足日益增长的客户需求。对某些模块和类型及处理进行了革命性的重写，运行效率提高不少。有参数类型的变化，比如 long * 到 qintptr * 等，更加适应后续的拓展以及同时对32 64位不同系统的兼容。
移动安全初探：窃取微信聊天记录、Hacking Android with Metasploit
weixin_34378767的博客
08-20 1933
在这篇文章中我们将讨论如何获取安卓、苹果设备中的微信聊天记录，并演示如何利用后门通过Metasploit对安卓设备进行控制。文章比较基础、可动手性强，有设备的童鞋不妨边阅读文章边操作，希望能激发大家对移动终端的安全兴趣。 (文章内容存在一定攻击性，目的在于普及终端安全知识、提高安全意识，如有非法使用，后果自负) “如何获取Android、iPhone手...
mysql_config 乱码_修改Linux下MySQL编码配置文件的办法，即中文乱码问题解决方法...
weixin_29693211的博客
02-02 165
关键词:Linux,MySQL,中文乱码环境：RHEL4.6、mysql-server-4.1.12现象：在此电脑上安装了Tomcat作为web服务器，部署了一个项目，通过jdbc连接到mysql数据库。但是发现中文输入输出乱码现象。注意：关于utf8和gbk的区别详细见：linux中文乱码问题解决办法，下面的配置中根据自己要求选择两种编码。解决步骤：1.找到mysql的配置文件，拷贝到etc目录...
配置文件乱码 导致 字符传输丢失问题
laokaizzz的专栏
08-19 356
controll层 A+B+C字符串 结果传到后台 变成A+B ,C 丢了。 经过检查发现，B是从配置文件中读取的，结尾存在乱码，导致后面的数据传输完是有问题的，用notepad++ 打开看是一串null跟在后面。 修改配置文件，正常了。 ...
linux中查询IP地址时出现所谓的“乱码”问题
:)一位靓仔偶然路过的博客
08-16 6816
如果你查询ip时出现乱码，那么检查以下两个文件，并参考配置，还是不行把电脑安全卫士什么的软件退出 /etc/sysconfig/network NETWORKING=yes NETWORKING_IPV6=no/etc/sysconfig/network-scripts/ifcfg-eth0 DEVICE=eth0 BOOTPROTO=static BROADCAST=192.168.1.2...
Git bash输入ipconfig出现乱码等
浪子天涯梦的博客
07-18 592
今天打开gitbash输入ipconfig想看下IP地址时，发现gitbash显示的内容和cmd窗口中显示的不一致，大致是这样的，默认的cmd中显示是中文的，这里显示是英文的，而且有一部分内容显示不正常。试了下读取一些中文文件名，发现那些都是能够正常显示出中文的，后面摸索下，找到一个解决方法。......
6to4 android,IPCONFIG
weixin_33789376的博客
05-30 84
Missed IPv6 connectivity on world IPv6 day? With this app you can use IPv6 now!IPv6Config allows to configure some of the IPv6 kernel settings. Currently, it allows to automatically enable the \"Priva...
ipconfig.txt 配置规则
最新发布
08-01
`ipconfig.txt`通常是一个文本文件，用于配置网络设置，特别是Windows系统下的命令行工具`ipconfig`。在这个文件中，你可以自定义一些IP地址、子网掩码、默认网关、DNS服务器等静态IP配置信息，而不是通过系统的动态获取过程（如DHCP）。用户可能会编辑这个文件来手动设定网络环境，例如固定分配给特定设备的IP地址。 要修改或查看`ipconfig.txt`的内容，你需要先以管理员权限打开记事本或其他支持文本编辑的应用，并保存文件名为`ipconfig.txt`（如果存在的话，一般位于系统目录下，如`%windir%\System32\drivers\etc`），然后添加或编辑相应的网络配置项。但是需要注意的是，不是所有系统都会自动寻找或识别这个文件，大部分现代操作系统更倾向于使用动态IP配置管理。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值