mika/switch-examples
1
0
Fork 0
mirror of https://github.com/switchbrew/switch-examples.git synced 2025-08-06 00:19:23 +02:00
Code Issues Packages Projects Releases Wiki Activity

Added network/lp2p.

Browse Source
This commit is contained in:
yellows8 2020-12-10 23:52:53 -05:00
parent a5f53afed0
commit 84be02950a
No known key found for this signature in database
GPG Key ID: 0AF90DA3F1E60E43
2 changed files with 438 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
network/lp2p/Makefile Normal file
View File

@ -0,0 +1,222 @@
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITPRO)),)
$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
endif
TOPDIR ?= $(CURDIR)
include $(DEVKITPRO)/libnx/switch_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code
# DATA is a list of directories containing data files
# INCLUDES is a list of directories containing header files
# ROMFS is the directory containing data to be added to RomFS, relative to the Makefile (Optional)
#
# NO_ICON: if set to anything, do not use icon.
# NO_NACP: if set to anything, no .nacp file is generated.
# APP_TITLE is the name of the app stored in the .nacp file (Optional)
# APP_AUTHOR is the author of the app stored in the .nacp file (Optional)
# APP_VERSION is the version of the app stored in the .nacp file (Optional)
# APP_TITLEID is the titleID of the app stored in the .nacp file (Optional)
# ICON is the filename of the icon (.jpg), relative to the project folder.
# If not set, it attempts to use one of the following (in this order):
# - <Project name>.jpg
# - icon.jpg
# - <libnx folder>/default_icon.jpg
#
# CONFIG_JSON is the filename of the NPDM config file (.json), relative to the project folder.
# If not set, it attempts to use one of the following (in this order):
# - <Project name>.json
# - config.json
# If a JSON file is provided or autodetected, an ExeFS PFS0 (.nsp) is built instead
# of a homebrew executable (.nro). This is intended to be used for sysmodules.
# NACP building is skipped as well.
#---------------------------------------------------------------------------------
TARGET := $(notdir $(CURDIR))
BUILD := build
SOURCES := source
DATA := data
INCLUDES := include
#ROMFS := romfs
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE
CFLAGS := -g -Wall -O2 -ffunction-sections \
$(ARCH) $(DEFINES)
CFLAGS += $(INCLUDE) -D__SWITCH__
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
LIBS := -lnx
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(PORTLIBS) $(LIBNX)
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
# rules for different file extensions
#---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export TOPDIR := $(CURDIR)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export OFILES_SRC := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES := $(OFILES_BIN) $(OFILES_SRC)
export HFILES_BIN := $(addsuffix .h,$(subst .,_,$(BINFILES)))
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(CONFIG_JSON)),)
jsons := $(wildcard *.json)
ifneq (,$(findstring $(TARGET).json,$(jsons)))
export APP_JSON := $(TOPDIR)/$(TARGET).json
else
ifneq (,$(findstring config.json,$(jsons)))
export APP_JSON := $(TOPDIR)/config.json
endif
endif
else
export APP_JSON := $(TOPDIR)/$(CONFIG_JSON)
endif
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.jpg)
ifneq (,$(findstring $(TARGET).jpg,$(icons)))
export APP_ICON := $(TOPDIR)/$(TARGET).jpg
else
ifneq (,$(findstring icon.jpg,$(icons)))
export APP_ICON := $(TOPDIR)/icon.jpg
endif
endif
else
export APP_ICON := $(TOPDIR)/$(ICON)
endif
ifeq ($(strip $(NO_ICON)),)
export NROFLAGS += --icon=$(APP_ICON)
endif
ifeq ($(strip $(NO_NACP)),)
export NROFLAGS += --nacp=$(CURDIR)/$(TARGET).nacp
endif
ifneq ($(APP_TITLEID),)
export NACPFLAGS += --titleid=$(APP_TITLEID)
endif
ifneq ($(ROMFS),)
export NROFLAGS += --romfsdir=$(CURDIR)/$(ROMFS)
endif
.PHONY: $(BUILD) clean all
#---------------------------------------------------------------------------------
all: $(BUILD)
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
ifeq ($(strip $(APP_JSON)),)
@rm -fr $(BUILD) $(TARGET).nro $(TARGET).nacp $(TARGET).elf
else
@rm -fr $(BUILD) $(TARGET).nsp $(TARGET).nso $(TARGET).npdm $(TARGET).elf
endif
#---------------------------------------------------------------------------------
else
.PHONY: all
DEPENDS := $(OFILES:.o=.d)
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
ifeq ($(strip $(APP_JSON)),)
all : $(OUTPUT).nro
ifeq ($(strip $(NO_NACP)),)
$(OUTPUT).nro : $(OUTPUT).elf $(OUTPUT).nacp
else
$(OUTPUT).nro : $(OUTPUT).elf
endif
else
all : $(OUTPUT).nsp
$(OUTPUT).nsp : $(OUTPUT).nso $(OUTPUT).npdm
$(OUTPUT).nso : $(OUTPUT).elf
endif
$(OUTPUT).elf : $(OFILES)
$(OFILES_SRC) : $(HFILES_BIN)
#---------------------------------------------------------------------------------
# you need a rule like this for each extension you use as binary data
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
@$(bin2o)
-include $(DEPENDS)
#---------------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------------

216
network/lp2p/source/main.c Normal file
View File

@ -0,0 +1,216 @@
// Include the most common headers from the C standard library
#include <string.h>
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/errno.h>
#include <unistd.h>
// Include the main libnx system header, for Switch development
#include <switch.h>
// This example shows how to use lp2p, for Switch-hosted local-network communications with mainly non-Switch devices. See also libnx lp2p.h.
// Note that in an actual app you may want to use lp2p/sockets from another thread.
Result create_network(const Lp2pGroupInfo *in_group_info) {
Result rc=0;
rc = lp2pCreateGroup(in_group_info);
printf("lp2pCreateGroup(): 0x%x\n", rc);
return rc;
}
void leave_network(void) {
Result rc=0;
u32 tmp32=0;
rc = lp2pLeave(&tmp32);
printf("lp2pLeave(): 0x%x, 0x%x\n", rc, tmp32);
rc = lp2pDestroyGroup();
printf("lp2pDestroyGroup(): 0x%x\n", rc);
}
void generate_random_str(char *str, size_t string_len) {
if (string_len & 1) string_len--;
for (size_t i=0; i<string_len; i+=2) {
u8 tmp=0;
randomGet(&tmp, sizeof(tmp));
snprintf(&str[i], 3, "%02X", tmp);
}
}
int main(int argc, char **argv)
{
// This example uses a text console, as a simple way to output text to the screen.
// If you want to write a software-rendered graphics application,
// take a look at the graphics/simplegfx example, which uses the libnx Framebuffer API instead.
// If on the other hand you want to write an OpenGL based application,
// take a look at the graphics/opengl set of examples, which uses EGL instead.
consoleInit(NULL);
// Configure our supported input layout: a single player with standard controller styles
padConfigureInput(1, HidNpadStyleSet_NpadStandard);
// Initialize the default gamepad (which reads handheld mode inputs as well as the first connected controller)
PadState pad;
padInitializeDefault(&pad);
// Initialise sockets
socketInitializeDefault();
printf("lp2p example\n");
int sockfd=-1;
struct sockaddr_in serv_addr;
Result rc=0;
Lp2pIpConfig ip_config={0};
Lp2pGroupInfo in_group_info={0};
Lp2pGroupInfo group_info={0};
lp2pCreateGroupInfo(&in_group_info);
// This example uses [11.0.0+] WPA2-PSK. If you want to use Nintendo-encryption for the network (for communicating with accessories such as mklive), use flags=1 (which is also the default), and replace the lp2pGroupInfoSetPassphrase call with lp2pGroupInfoSetPresharedKey.
// If you want to use plaintext (open network), set in_group_info.security_type manually, and call lp2pGroupInfoSetPresharedKey (where the used keydata doesn't matter).
s8 flags=0;
lp2pGroupInfoSetFlags(&in_group_info, &flags, 1);
// See lp2p.h Lp2pGroupInfo::service_name.
char ssid[0x20] = {"libnxlp2p-"};
char passphrase[0x40] = {0};
generate_random_str(&ssid[strlen(ssid)], 8);
generate_random_str(passphrase, 16);
lp2pGroupInfoSetServiceName(&in_group_info, ssid);
lp2pGroupInfoSetPassphrase(&in_group_info, passphrase);
rc = lp2pInitialize(Lp2pServiceType_App);
printf("lp2pInitialize(): 0x%x\n", rc);
if (R_SUCCEEDED(rc)) {
printf("Press A to create a network.\n");
printf("Press X to leave a network.\n");
printf("Press the D-Pad buttons while on a network to send messages.\n");
}
printf("Press + to exit.\n");
// Main loop
while(appletMainLoop())
{
// Scan the gamepad. This should be done once for each frame
padUpdate(&pad);
// padGetButtonsDown returns the set of buttons that have been newly pressed in this frame compared to the previous one
u32 kDown = padGetButtonsDown(&pad);
if (kDown & HidNpadButton_Plus) break; // break in order to return to hbmenu
if (R_SUCCEEDED(rc) && (kDown & HidNpadButton_A)) {
Result rc2 = create_network(&in_group_info);
printf("create_network(): 0x%x\n", rc2);
// We didn't set the full ServiceName, so the sysmodule will generate the rest of it. Use lp2pGetGroupInfo to get the actual ServiceName.
if (R_SUCCEEDED(rc2)) {
rc2 = lp2pGetGroupInfo(&group_info);
printf("lp2pGetGroupInfo(): 0x%x\n", rc2);
}
if (R_SUCCEEDED(rc2)) {
rc2 = lp2pGetIpConfig(&ip_config);
printf("lp2pGetIpConfig(): 0x%x\n", rc2);
}
if (R_SUCCEEDED(rc2)) {
printf("Network created.\nSSID: %s\nPassphrase: %s\n", group_info.service_name, passphrase);
}
// Once on a network, you can use whatever sockets you want. In this example, we'll send/recv data with UDP-broadcast.
if (R_SUCCEEDED(rc2)) {
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
printf("socket() failed\n");
}
else {
int ret=0;
int optval = 1;
ret = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval));
if (ret==-1) {
printf("setsockopt() failed\n");
close(sockfd);
sockfd = -1;
}
// Setup a broadcast addr. If you want to use IP addrs for members on the network, see lp2pGetMembers().
if (sockfd >= 0) {
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(ntohl(((struct sockaddr_in*)ip_config.ip_addr)->sin_addr.s_addr) | ~ntohl(((struct sockaddr_in*)ip_config.subnet_mask)->sin_addr.s_addr));
serv_addr.sin_port = htons(7777);
if (bind(sockfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0) {
printf("bind failed\n");
close(sockfd);
sockfd = -1;
}
}
}
}
}
if (R_SUCCEEDED(rc) && (kDown & HidNpadButton_X)) {
if (sockfd >= 0) {
close(sockfd);
sockfd = -1;
}
leave_network();
}
if (R_SUCCEEDED(rc) && sockfd>=0 && (kDown & (HidNpadButton_Left|HidNpadButton_Right|HidNpadButton_Up|HidNpadButton_Down))) {
char tmpstr[32];
memset(tmpstr, 0, sizeof(tmpstr));
if (kDown & HidNpadButton_Left) strncpy(tmpstr, "Button Left pressed.", sizeof(tmpstr)-1);
else if (kDown & HidNpadButton_Right) strncpy(tmpstr, "Button Right pressed.", sizeof(tmpstr)-1);
else if (kDown & HidNpadButton_Up) strncpy(tmpstr, "Button Up pressed.", sizeof(tmpstr)-1);
else if (kDown & HidNpadButton_Down) strncpy(tmpstr, "Button Down pressed.", sizeof(tmpstr)-1);
ssize_t ret = sendto(sockfd, tmpstr, sizeof(tmpstr), 0, (struct sockaddr*) &serv_addr, sizeof(struct sockaddr_in));
int tmp = errno;
printf("sendto(): %ld", ret);
if (ret < 0) printf(", %s", strerror(tmp));
printf("\n");
}
if (R_SUCCEEDED(rc) && sockfd>=0) {
char tmpstr[32];
memset(tmpstr, 0, sizeof(tmpstr));
struct sockaddr_in src_addr={0};
socklen_t fromlen = sizeof(struct sockaddr_in);
ssize_t ret = recvfrom(sockfd, tmpstr, sizeof(tmpstr), MSG_DONTWAIT, (struct sockaddr*) &src_addr, &fromlen);
tmpstr[sizeof(tmpstr)-1] = 0;
if (ret>0) printf("Received data: %s\n", tmpstr);
}
consoleUpdate(NULL);
}
if (sockfd >= 0) {
close(sockfd);
sockfd = -1;
}
leave_network();
lp2pExit();
socketExit();
consoleExit(NULL);
return 0;
}