The-Homebrew-Cloud/JWUPClient
2
0
Fork 0
mirror of https://github.com/Maschell/JWUPClient.git synced 2024-11-14 20:25:11 +01:00
Code Issues Packages Projects Releases Wiki Activity

Refactored the existing functions and added new functions

Browse Source 
Added:
repeatwrite
dump_syslog
This commit is contained in:
Maschell 2016-10-24 00:49:25 +02:00
parent e7d82b8806
commit 8e6187ab0f
9 changed files with 360 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/de/mas/wupclient/Starter.java
View File

@ -2,6 +2,7 @@ package de.mas.wupclient;
import java.io.IOException; import java.io.IOException;
import de.mas.wupclient.client.WUPClient; import de.mas.wupclient.client.WUPClient;
import de.mas.wupclient.client.operations.DownloadUploadOperations;
import de.mas.wupclient.client.operations.UtilOperations; import de.mas.wupclient.client.operations.UtilOperations;
import de.mas.wupclient.client.utils.Logger; import de.mas.wupclient.client.utils.Logger;
@ -14,10 +15,13 @@ public class Starter {
WUPClient w = new WUPClient(ip); WUPClient w = new WUPClient(ip);
try { try {
UtilOperations util = UtilOperations.UtilOperationsFactory(w); UtilOperations util = UtilOperations.UtilOperationsFactory(w);
DownloadUploadOperations dlul = DownloadUploadOperations.DownloadUploadOperationsFactory(w);
util.dump_syslog();
Logger.logCmd("Lets into the " + w.getCwd() + "/sys/title/00050010/10040200/" + " folder!"); Logger.logCmd("Lets into the " + w.getCwd() + "/sys/title/00050010/10040200/" + " folder!");
util.lsRecursive(w.getCwd() + "/sys/title/00050010/10040200/"); util.lsRecursive(w.getCwd() + "/sys/title/00050010/10040200/");
Logger.logCmd("And download the /code/app.xml to /test/app.xml"); Logger.logCmd("And download the /code/app.xml to /test/app.xml");
util.downloadFile(w.getCwd() + "/sys/title/00050010/10040200/code", "app.xml", "test", null); dlul.downloadFile(w.getCwd() + "/sys/title/00050010/10040200/code", "app.xml", "test", null);
Logger.logCmd("done!"); Logger.logCmd("done!");
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); e.printStackTrace();

121
src/de/mas/wupclient/client/WUPClient.java
View File

@ -5,11 +5,12 @@ import java.io.IOException;
import java.net.Socket; import java.net.Socket;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays; import java.util.Arrays;
import de.mas.wupclient.client.operations.SystemOperations;
import de.mas.wupclient.client.utils.Logger; import de.mas.wupclient.client.utils.Logger;
import de.mas.wupclient.client.utils.Result; import de.mas.wupclient.client.utils.Result;
import de.mas.wupclient.client.utils.Utils;
public class WUPClient { public class WUPClient {
private String IP; private String IP;
@ -20,24 +21,19 @@ public class WUPClient {
public WUPClient(String ip){ public WUPClient(String ip){
setIP(ip); setIP(ip);
createSocket(ip); createSocket(ip);
setFsaHandle(-1); setFSAHandle(-1);
setCwd("/vol/storage_mlc01"); setCwd("/vol/storage_mlc01");
} }
public Result<byte[]> send(int command, byte[] data) throws IOException{ public Result<byte[]> send(int command, byte[] data) throws IOException{
DataOutputStream outToServer = new DataOutputStream(getSocket().getOutputStream()); DataOutputStream outToServer = new DataOutputStream(getSocket().getOutputStream());
ByteBuffer destByteBuffer = ByteBuffer.allocate(data.length + 4);
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.putInt(command);
destByteBuffer.put(data);
try { try {
outToServer.write(destByteBuffer.array()); outToServer.write(Utils.m_packBE(command,data));
} catch (IOException e) { } catch (IOException e) {
Logger.logErr("send failed"); Logger.logErr("send failed");
e.printStackTrace(); e.printStackTrace();
} }
destByteBuffer.clear(); ByteBuffer destByteBuffer = ByteBuffer.allocate(0x600);
destByteBuffer = ByteBuffer.allocate(0x600);
byte[] result = new byte[0x0600]; byte[] result = new byte[0x0600];
int size = getSocket().getInputStream().read(result); int size = getSocket().getInputStream().read(result);
destByteBuffer.put(result, 0, size); destByteBuffer.put(result, 0, size);
@ -46,11 +42,7 @@ public class WUPClient {
} }
public byte[] read(int addr, int len) throws IOException{ public byte[] read(int addr, int len) throws IOException{
ByteBuffer destByteBuffer = ByteBuffer.allocate(8); Result<byte[]> result = send(1, Utils.m_packBE(addr,len));
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.putInt(addr);
destByteBuffer.putInt(len);
Result<byte[]> result = send(1,destByteBuffer.array());
if(result.getResultValue() == 0){ if(result.getResultValue() == 0){
return result.getData(); return result.getData();
}else{ }else{
@ -60,12 +52,7 @@ public class WUPClient {
} }
public int write(int addr, byte[] data ) throws IOException{ public int write(int addr, byte[] data ) throws IOException{
ByteBuffer destByteBuffer = ByteBuffer.allocate(4 + data.length); Result<byte[]> result = send(0,Utils.m_packBE(addr,data));
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.putInt(addr);
destByteBuffer.put(data);
Result<byte[]> result = send(0,destByteBuffer.array());
if(result.getResultValue() == 0){ if(result.getResultValue() == 0){
return result.getResultValue(); return result.getResultValue();
}else{ }else{
@ -75,19 +62,9 @@ public class WUPClient {
} }
public int svc(int svc_id, int[] arguments) throws IOException{ public int svc(int svc_id, int[] arguments) throws IOException{
ByteBuffer destByteBuffer = ByteBuffer.allocate(4 + (arguments.length * 0x04)); Result<byte[]> result = send(2,Utils.m_packBE(svc_id,arguments));
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.putInt(svc_id);
for(int i = 0;i<arguments.length;i++){
destByteBuffer.putInt(arguments[i]);
}
Result<byte[]> result = send(2,destByteBuffer.array());
if(result.getResultValue() == 0){ if(result.getResultValue() == 0){
destByteBuffer = ByteBuffer.allocate(0x04); return Utils.bigEndianByteArrayToInt(Arrays.copyOfRange(result.getData(), 0, 0x04));
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.put(Arrays.copyOfRange(result.getData(), 0, 0x04));
return destByteBuffer.getInt(0);
}else{ }else{
Logger.logErr("svc error: " + result.getResultValue()); Logger.logErr("svc error: " + result.getResultValue());
return -1; return -1;
@ -100,12 +77,7 @@ public class WUPClient {
} }
public int memcpy(int dest, int source, int len) throws IOException{ public int memcpy(int dest, int source, int len) throws IOException{
ByteBuffer destByteBuffer = ByteBuffer.allocate(12); Result<byte[]> result = send(4, Utils.m_packBE(dest,source,len));
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.putInt(dest);
destByteBuffer.putInt(source);
destByteBuffer.putInt(len);
Result<byte[]> result = send(4,destByteBuffer.array());
if(result.getResultValue() == 0){ if(result.getResultValue() == 0){
return result.getResultValue(); return result.getResultValue();
}else{ }else{
@ -113,75 +85,29 @@ public class WUPClient {
return -1; return -1;
} }
} }
public int alloc(int size) throws IOException{
return alloc(size,0x00); public int repeatwrite(int dest, int val, int n) throws IOException{
} Result<byte[]> result = send(5, Utils.m_packBE(dest,val,n));
public int alloc(int size, int align) throws IOException{ if(result.getResultValue() == 0){
if(size == 0){ return result.getResultValue();
return 0;
}
if(align == 0){
int result = svc(0x27, new int[] {0xCAFF,size});
return result;
}else{ }else{
int result = svc(0x28, new int[] {0xCAFF,size,align}); Logger.logErr("repeatwrite error: " + result.getResultValue());
return result; return -1;
} }
} }
public int free(int address) throws IOException{
if(address == 0){
return 0;
}
return svc(0x29, new int[] {0xCAFF,address});
}
public int load_buffer(byte[] data) throws IOException{
return load_buffer(data,0x00);
}
public int load_buffer(byte[] data,int align) throws IOException{
if(data.length == 0)
return 0;
int address = alloc(data.length, align);
write(address, data);
return address;
}
public int load_string(String b) throws IOException{
return load_string(b,0x00);
}
public int load_string(String b,int align) throws IOException{
byte[] buffer = b.getBytes();
byte[] newBuffer = new byte[buffer.length+1];
System.arraycopy(buffer, 0, newBuffer, 0, buffer.length);
newBuffer[buffer.length] = 0;
int result = load_buffer(newBuffer, align);
return result;
}
public int open(String device, int mode) throws IOException{
int address = load_string(device);
int handle = svc(0x33, new int[] {address,mode});
free(address);
return handle;
}
public int close(int handle) throws IOException{
return svc(0x34,new int[]{handle});
}
public int get_fsa_handle() throws IOException{ public int get_fsa_handle() throws IOException{
if(getFsaHandle()== -1){ if(fsaHandle == -1){
setFsaHandle(open("/dev/fsa", 0)); setFSAHandle(SystemOperations.SystemOperationsFactory(this).open("/dev/fsa", 0));
} }
return getFsaHandle(); return fsaHandle;
} }
public int FSA_Close(int handle) throws IOException{ public int FSA_Close(int handle) throws IOException{
int result = svc(0x34, new int[]{handle}); int result = svc(0x34, new int[]{handle});
if(result == 0){ if(result == 0){
setFsaHandle(-1); setFSAHandle(-1);
}else{ }else{
Logger.logErr("FSA_Close: failed"); Logger.logErr("FSA_Close: failed");
} }
@ -219,10 +145,7 @@ public class WUPClient {
public void setIP(String iP) { public void setIP(String iP) {
IP = iP; IP = iP;
} }
private int getFsaHandle() { public void setFSAHandle(int fsaHandle) {
return fsaHandle;
}
public void setFsaHandle(int fsaHandle) {
this.fsaHandle = fsaHandle; this.fsaHandle = fsaHandle;
} }
public String getCwd() { public String getCwd() {

136
src/de/mas/wupclient/client/operations/DownloadUploadOperations.java Normal file
View File

@ -0,0 +1,136 @@
package de.mas.wupclient.client.operations;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import de.mas.wupclient.client.WUPClient;
import de.mas.wupclient.client.utils.FEntry;
import de.mas.wupclient.client.utils.Logger;
import de.mas.wupclient.client.utils.Result;
import de.mas.wupclient.client.utils.Utils;
public class DownloadUploadOperations extends Operations {
private static Map<WUPClient,DownloadUploadOperations> instances = new HashMap<>();
public static DownloadUploadOperations DownloadUploadOperationsFactory(WUPClient client){
if(!instances.containsKey(client)){
instances.put(client, new DownloadUploadOperations(client));
}
return instances.get(client);
}
private UtilOperations util = null;
private FSAOperations fsa = null;
public DownloadUploadOperations(WUPClient client) {
super(client);
setUtil(UtilOperations.UtilOperationsFactory(client));
setFSA(FSAOperations.FSAOperationsFactory(client));
}
public boolean downloadFolder(String path) throws IOException{
return downloadFolder(path,null,false);
}
public boolean downloadFolder(String sourcePath,String targetPath) throws IOException{
return downloadFolder(sourcePath,targetPath,false);
}
public boolean downloadFolder(String sourcePath, String targetPath,boolean useRelativPath) throws IOException {
List<FEntry> files = util.ls(sourcePath,true);
if(targetPath == null || targetPath.isEmpty()){
targetPath = sourcePath;
}
for(FEntry f: files){
if(f.isFile()){
downloadFile(sourcePath, f.getFilename(),targetPath);
}else{
downloadFolder(sourcePath + "/" + f.getFilename(), targetPath,useRelativPath);
}
}
return false;
}
public byte[] downloadFileToByteArray(String path) throws IOException{
Logger.logCmd("Downloading " + path);
int fsa_handle = getClient().get_fsa_handle();
Result<Integer> res = fsa.FSA_OpenFile(fsa_handle, path, "r");
boolean success = false;
byte[] result = null;
if(res.getResultValue() == 0){
int block_size = 0x400;
ByteArrayOutputStream out = new ByteArrayOutputStream();
success = true;
while(true){
Result<byte[]> read_result= fsa.FSA_ReadFile(fsa_handle, res.getData(), 0x1, block_size);
if(read_result.getResultValue() <0){
Logger.logErr("FSA_ReadFile returned " + read_result.getResultValue());
success = false;
break;
}
out.write(Arrays.copyOf(read_result.getData(), read_result.getResultValue()));
if(read_result.getResultValue() <= 0)
break;
}
fsa.FSA_CloseFile(fsa_handle, res.getData());
if(success){
result = out.toByteArray();
}
}
return result;
}
public boolean downloadFile(String sourcePath, String filename, String targetPath) throws IOException {
return downloadFile(sourcePath, filename, targetPath,null);
}
public boolean downloadFile(String sourcePath,String sourceFilename,String targetPath,String targetFileName) throws IOException {
byte[] data = downloadFileToByteArray(sourcePath + "/" + sourceFilename);
if(data == null){
System.out.println("failed");
return false;
}
String subdir = "";
if(targetFileName == null){
subdir += targetPath + "/" + sourceFilename;
}else{
subdir += targetPath + "/" + targetFileName;
}
if(subdir.startsWith("/")){
subdir = subdir.substring(1);
}
Utils.createSubfolder(subdir);
FileOutputStream stream = new FileOutputStream(subdir);
try {
stream.write(data);
} finally {
stream.close();
}
return true;
}
public UtilOperations getUtil() {
return util;
}
public void setUtil(UtilOperations util) {
this.util = util;
}
public FSAOperations getFSA() {
return fsa;
}
public void setFSA(FSAOperations fsa) {
this.fsa = fsa;
}
}

30
src/de/mas/wupclient/client/operations/FSAOperations.java
View File

@ -20,26 +20,26 @@ public class FSAOperations extends Operations {
return instances.get(client); return instances.get(client);
} }
private IoctlOperations ioctl = null; private SystemOperations system = null;
private FSAOperations(WUPClient client) { private FSAOperations(WUPClient client) {
super(client); super(client);
setIoctlOperations(IoctlOperations.IoctlOperationsFactory(client)); setIoctlOperations(SystemOperations.SystemOperationsFactory(client));
} }
public IoctlOperations getIoctlOperations() { public SystemOperations getIoctlOperations() {
return ioctl; return system;
} }
public void setIoctlOperations(IoctlOperations ioctl) { public void setIoctlOperations(SystemOperations ioctl) {
this.ioctl = ioctl; this.system = ioctl;
} }
public Result<Integer> FSA_OpenDir(int handle, String path) throws IOException{ public Result<Integer> FSA_OpenDir(int handle, String path) throws IOException{
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeNullTerminatedStringToByteArray(inbuffer, path, 0x04); Utils.writeNullTerminatedStringToByteArray(inbuffer, path, 0x04);
Result<byte[]> res = ioctl.ioctl(handle, 0x0A, inbuffer, 0x293); Result<byte[]> res = system.ioctl(handle, 0x0A, inbuffer, 0x293);
return new Result<Integer>(res.getResultValue(),Utils.bigEndianByteArrayToInt(Arrays.copyOfRange(res.getData(), 0x04, 0x08))); return new Result<Integer>(res.getResultValue(),Utils.bigEndianByteArrayToInt(Arrays.copyOfRange(res.getData(), 0x04, 0x08)));
} }
@ -47,7 +47,7 @@ public class FSAOperations extends Operations {
public int FSA_CloseDir(int handle, int dirhandle) throws IOException{ public int FSA_CloseDir(int handle, int dirhandle) throws IOException{
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeIntToByteArray(inbuffer, dirhandle, 0x04); Utils.writeIntToByteArray(inbuffer, dirhandle, 0x04);
Result<byte[]> res = ioctl.ioctl(handle, 0x0D, inbuffer, 0x293); Result<byte[]> res = system.ioctl(handle, 0x0D, inbuffer, 0x293);
return res.getResultValue(); return res.getResultValue();
} }
@ -55,7 +55,7 @@ public class FSAOperations extends Operations {
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeIntToByteArray(inbuffer,dirhandle,4); Utils.writeIntToByteArray(inbuffer,dirhandle,4);
Result<byte[]> res = ioctl.ioctl(fsa_handle, 0x0B, inbuffer, 0x293); Result<byte[]> res = system.ioctl(fsa_handle, 0x0B, inbuffer, 0x293);
byte[] unknowndata = Arrays.copyOfRange(res.getData(), 0x04, 0x68); byte[] unknowndata = Arrays.copyOfRange(res.getData(), 0x04, 0x68);
String filename = Utils.getStringFromByteArray(Arrays.copyOfRange(res.getData(), 0x68, res.getData().length)); String filename = Utils.getStringFromByteArray(Arrays.copyOfRange(res.getData(), 0x68, res.getData().length));
@ -73,7 +73,7 @@ public class FSAOperations extends Operations {
Utils.writeNullTerminatedStringToByteArray(inbuffer, volume_path, 0x0284); Utils.writeNullTerminatedStringToByteArray(inbuffer, volume_path, 0x0284);
Utils.writeIntToByteArray(inbuffer,flags,0x0504); Utils.writeIntToByteArray(inbuffer,flags,0x0504);
Result<byte[][]> result = ioctl.ioctlv(handle, 0x01, new byte[][] {inbuffer,new byte[0]}, new int[]{0x293}); Result<byte[][]> result = system.ioctlv(handle, 0x01, new byte[][] {inbuffer,new byte[0]}, new int[]{0x293});
return result.getResultValue(); return result.getResultValue();
} }
@ -82,7 +82,7 @@ public class FSAOperations extends Operations {
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeNullTerminatedStringToByteArray(inbuffer, volume_path, 0x04); Utils.writeNullTerminatedStringToByteArray(inbuffer, volume_path, 0x04);
Utils.writeIntToByteArray(inbuffer,flags,0x284); Utils.writeIntToByteArray(inbuffer,flags,0x284);
Result<byte[]> result = ioctl.ioctl(handle,0x02,inbuffer,0x293); Result<byte[]> result = system.ioctl(handle,0x02,inbuffer,0x293);
return result.getResultValue(); return result.getResultValue();
} }
@ -90,7 +90,7 @@ public class FSAOperations extends Operations {
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeNullTerminatedStringToByteArray(inbuffer, path, 0x04); Utils.writeNullTerminatedStringToByteArray(inbuffer, path, 0x04);
Utils.writeIntToByteArray(inbuffer,flags,0x284); Utils.writeIntToByteArray(inbuffer,flags,0x284);
Result<byte[]> result = ioctl.ioctl(handle, 0x07, inbuffer, 0x293); Result<byte[]> result = system.ioctl(handle, 0x07, inbuffer, 0x293);
return result.getResultValue(); return result.getResultValue();
} }
@ -98,7 +98,7 @@ public class FSAOperations extends Operations {
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeNullTerminatedStringToByteArray(inbuffer, path, 0x04); Utils.writeNullTerminatedStringToByteArray(inbuffer, path, 0x04);
Utils.writeNullTerminatedStringToByteArray(inbuffer, mode, 0x284); Utils.writeNullTerminatedStringToByteArray(inbuffer, mode, 0x284);
Result<byte[]> result = ioctl.ioctl(handle, 0x0E, inbuffer, 0x293); Result<byte[]> result = system.ioctl(handle, 0x0E, inbuffer, 0x293);
return new Result<Integer>(result.getResultValue(),Utils.bigEndianByteArrayToInt(Arrays.copyOfRange(result.getData(), 0x04, 0x08))); return new Result<Integer>(result.getResultValue(),Utils.bigEndianByteArrayToInt(Arrays.copyOfRange(result.getData(), 0x04, 0x08)));
} }
@ -106,7 +106,7 @@ public class FSAOperations extends Operations {
public int FSA_CloseFile(int handle, int file_handle) throws IOException{ public int FSA_CloseFile(int handle, int file_handle) throws IOException{
byte[] inbuffer = new byte[0x520]; byte[] inbuffer = new byte[0x520];
Utils.writeIntToByteArray(inbuffer, file_handle, 0x04); Utils.writeIntToByteArray(inbuffer, file_handle, 0x04);
Result<byte[]> res = ioctl.ioctl(handle, 0x15, inbuffer, 0x293); Result<byte[]> res = system.ioctl(handle, 0x15, inbuffer, 0x293);
return res.getResultValue(); return res.getResultValue();
} }
@ -115,7 +115,7 @@ public class FSAOperations extends Operations {
Utils.writeIntToByteArray(inbuffer, size, 0x08); Utils.writeIntToByteArray(inbuffer, size, 0x08);
Utils.writeIntToByteArray(inbuffer, cnt, 0x0C); Utils.writeIntToByteArray(inbuffer, cnt, 0x0C);
Utils.writeIntToByteArray(inbuffer, file_handle, 0x14); Utils.writeIntToByteArray(inbuffer, file_handle, 0x14);
Result<byte[][]> result = ioctl.ioctlv(handle, 0x0F, new byte[][] {inbuffer}, new int[]{size * cnt,0x293}); Result<byte[][]> result = system.ioctlv(handle, 0x0F, new byte[][] {inbuffer}, new int[]{size * cnt,0x293});
return new Result<byte[]>(result.getResultValue(),result.getData()[0]); return new Result<byte[]>(result.getResultValue(),result.getData()[0]);
} }

31
src/de/mas/wupclient/client/operations/MCPOperations.java Normal file
View File

@ -0,0 +1,31 @@
package de.mas.wupclient.client.operations;
import java.util.HashMap;
import java.util.Map;
import de.mas.wupclient.client.WUPClient;
public class MCPOperations extends Operations {
private static Map<WUPClient,DownloadUploadOperations> instances = new HashMap<>();
public static DownloadUploadOperations DownloadUploadOperationsFactory(WUPClient client){
if(!instances.containsKey(client)){
instances.put(client, new DownloadUploadOperations(client));
}
return instances.get(client);
}
SystemOperations system = null;
public MCPOperations(WUPClient client) {
super(client);
setSystem(SystemOperations.SystemOperationsFactory(client));
}
public SystemOperations getSystem() {
return system;
}
public void setSystem(SystemOperations system) {
this.system = system;
}
}

100
src/de/mas/wupclient/client/operations/IoctlOperations.java → src/de/mas/wupclient/client/operations/SystemOperations.java
View File

@ -10,33 +10,33 @@ import de.mas.wupclient.client.WUPClient;
import de.mas.wupclient.client.utils.Result; import de.mas.wupclient.client.utils.Result;
import de.mas.wupclient.client.utils.Utils; import de.mas.wupclient.client.utils.Utils;
public class IoctlOperations extends Operations { public class SystemOperations extends Operations {
private static Map<WUPClient,IoctlOperations> instances = new HashMap<>(); private static Map<WUPClient,SystemOperations> instances = new HashMap<>();
public static IoctlOperations IoctlOperationsFactory(WUPClient client){ public static SystemOperations SystemOperationsFactory(WUPClient client){
if(!instances.containsKey(client)){ if(!instances.containsKey(client)){
instances.put(client, new IoctlOperations(client)); instances.put(client, new SystemOperations(client));
} }
return instances.get(client); return instances.get(client);
} }
private IoctlOperations(WUPClient client) { private SystemOperations(WUPClient client) {
super(client); super(client);
} }
public Result<byte[]> ioctl(int handle,int cmd, byte[] inbuf,int outbuf_size) throws IOException{ public Result<byte[]> ioctl(int handle,int cmd, byte[] inbuf,int outbuf_size) throws IOException{
int in_address = getClient().load_buffer(inbuf); int in_address = load_buffer(inbuf);
byte[] out_data = new byte[0]; byte[] out_data = new byte[0];
int ret; int ret;
if(outbuf_size > 0){ if(outbuf_size > 0){
int out_address = getClient().alloc(outbuf_size); int out_address = alloc(outbuf_size);
ret = getClient().svc(0x38, new int[] {handle,cmd,in_address,inbuf.length,out_address,outbuf_size}); ret = getClient().svc(0x38, new int[] {handle,cmd,in_address,inbuf.length,out_address,outbuf_size});
out_data = getClient().read(out_address, outbuf_size); out_data = getClient().read(out_address, outbuf_size);
getClient().free(out_address); free(out_address);
}else{ }else{
ret = getClient().svc(0x38, new int[] {handle,cmd,in_address,inbuf.length,0,0}); ret = getClient().svc(0x38, new int[] {handle,cmd,in_address,inbuf.length,0,0});
} }
getClient().free(in_address); free(in_address);
return new Result<byte[]>(ret,out_data); return new Result<byte[]>(ret,out_data);
} }
@ -48,24 +48,25 @@ public class IoctlOperations extends Operations {
destByteBuffer.putInt(data[1]); destByteBuffer.putInt(data[1]);
destByteBuffer.putInt(0); destByteBuffer.putInt(0);
} }
return getClient().load_buffer(destByteBuffer.array()); return load_buffer(destByteBuffer.array());
}
public Result<byte[][]> ioctlv(int handle, int cmd, byte[][] inbufs, int[] outbuf_sizes) throws IOException {
return ioctlv(handle,cmd,inbufs,outbuf_sizes,new int[0][],new int[0][]);
} }
/**
* UNTESTED!
*/
public Result<byte[][]> ioctlv(int handle, int cmd,byte[][] inbufs,int[] outbuf_sizes,int[][] ínbufs_ptr,int[][] outbufs_ptr) throws IOException{ public Result<byte[][]> ioctlv(int handle, int cmd,byte[][] inbufs,int[] outbuf_sizes,int[][] ínbufs_ptr,int[][] outbufs_ptr) throws IOException{
int new_inbufs[][] = new int[inbufs.length][2]; int new_inbufs[][] = new int[inbufs.length][2];
int i = 0; int i = 0;
for(byte[] data : inbufs){ for(byte[] data : inbufs){
new_inbufs[i][0] = getClient().load_buffer(data, 0x40); new_inbufs[i][0] = load_buffer(data, 0x40);
new_inbufs[i][1] = data.length; new_inbufs[i][1] = data.length;
i++; i++;
} }
int new_outbufs[][] = new int[outbuf_sizes.length][2]; int new_outbufs[][] = new int[outbuf_sizes.length][2];
i = 0; i = 0;
for(int cur_size : outbuf_sizes){ for(int cur_size : outbuf_sizes){
new_outbufs[i][0] = getClient().alloc(cur_size, 0x40); new_outbufs[i][0] = alloc(cur_size, 0x40);
new_outbufs[i][1] = cur_size; new_outbufs[i][1] = cur_size;
i++; i++;
} }
@ -83,14 +84,75 @@ public class IoctlOperations extends Operations {
i=0; i=0;
int[][] free_buffer = Utils.concatAll(new_inbufs,new_outbufs); int[][] free_buffer = Utils.concatAll(new_inbufs,new_outbufs);
for (int[] foo : free_buffer){ for (int[] foo : free_buffer){
getClient().free(foo[0]); free(foo[0]);
i++; i++;
} }
getClient().free(iovecs); free(iovecs);
return new Result<byte[][]>(ret,out_data); return new Result<byte[][]>(ret,out_data);
} }
public Result<byte[][]> ioctlv(int handle, int cmd, byte[][] inbufs, int[] outbuf_sizes) throws IOException {
return ioctlv(handle,cmd,inbufs,outbuf_sizes,new int[0][],new int[0][]); public int alloc(int size) throws IOException{
return alloc(size,0x00);
} }
public int alloc(int size, int align) throws IOException{
if(size == 0){
return 0;
}
if(align == 0){
int result = getClient().svc(0x27, new int[] {0xCAFF,size});
return result;
}else{
int result = getClient().svc(0x28, new int[] {0xCAFF,size,align});
return result;
}
}
public int free(int address) throws IOException{
if(address == 0){
return 0;
}
return getClient().svc(0x29, new int[] {0xCAFF,address});
}
public int load_buffer(byte[] data) throws IOException{
return load_buffer(data,0x00);
}
public int load_buffer(byte[] data,int align) throws IOException{
if(data.length == 0)
return 0;
int address = alloc(data.length, align);
getClient().write(address, data);
return address;
}
public int load_string(String b) throws IOException{
return load_string(b,0x00);
}
public int load_string(String b,int align) throws IOException{
byte[] buffer = b.getBytes();
byte[] newBuffer = new byte[buffer.length+1];
System.arraycopy(buffer, 0, newBuffer, 0, buffer.length);
newBuffer[buffer.length] = 0;
int result = load_buffer(newBuffer, align);
return result;
}
public int open(String device, int mode) throws IOException{
int address = load_string(device);
int handle = getClient().svc(0x33, new int[] {address,mode});
free(address);
return handle;
}
public int close(int handle) throws IOException{
return getClient().svc(0x34,new int[]{handle});
}
} }

121
src/de/mas/wupclient/client/operations/UtilOperations.java
View File

@ -1,10 +1,7 @@
package de.mas.wupclient.client.operations; package de.mas.wupclient.client.operations;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -25,10 +22,12 @@ public class UtilOperations extends Operations {
} }
private FSAOperations fsa = null; private FSAOperations fsa = null;
private SystemOperations system = null;
private UtilOperations(WUPClient client) { private UtilOperations(WUPClient client) {
super(client); super(client);
setFSAOperations(FSAOperations.FSAOperationsFactory(client)); setFSAOperations(FSAOperations.FSAOperationsFactory(client));
setSystem(SystemOperations.SystemOperationsFactory(client));
} }
public List<FEntry> ls() throws IOException{ public List<FEntry> ls() throws IOException{
return ls(null,false); return ls(null,false);
@ -102,6 +101,24 @@ public class UtilOperations extends Operations {
} }
} }
} }
public void dump_syslog() throws IOException {
int syslog_address = Utils.bigEndianByteArrayToInt(getClient().read(0x05095ECC, 4)) + 0x10;
int block_size = 0x400;
for(int i = 0;i<0x40000;i += block_size){
byte[] data = getClient().read(syslog_address + i, block_size);
String log = Utils.getStringFromByteArray(data);
if(!log.isEmpty()){
System.out.println(log);
}else{
break;
}
}
}
public int mkdir(String path, int flags) throws IOException{
int fsa_handle = getClient().get_fsa_handle();
return fsa.FSA_MakeDir(fsa_handle, path, 2);
}
public int mount(String device_path, String volume_path, int flags) throws IOException{ public int mount(String device_path, String volume_path, int flags) throws IOException{
int fsa_handle = getClient().get_fsa_handle(); int fsa_handle = getClient().get_fsa_handle();
@ -136,101 +153,17 @@ public class UtilOperations extends Operations {
return unmount("/vol/storage_odd_ticket", 2); return unmount("/vol/storage_odd_ticket", 2);
} }
public int mkdir(String path, int flags) throws IOException{
int fsa_handle = getClient().get_fsa_handle();
return fsa.FSA_MakeDir(fsa_handle, path, 2);
}
public boolean downloadFolder(String path) throws IOException{
return downloadFolder(path,null,false);
}
public boolean downloadFolder(String sourcePath,String targetPath) throws IOException{
return downloadFolder(sourcePath,targetPath,false);
}
public boolean downloadFolder(String sourcePath, String targetPath,boolean useRelativPath) throws IOException {
List<FEntry> files = ls(sourcePath,true);
if(targetPath == null || targetPath.isEmpty()){
targetPath = sourcePath;
}
for(FEntry f: files){
if(f.isFile()){
downloadFile(sourcePath, f.getFilename(),targetPath);
}else{
downloadFolder(sourcePath + "/" + f.getFilename(), targetPath,useRelativPath);
}
}
return false;
}
public byte[] downloadFileToByteArray(String path) throws IOException{
Logger.logCmd("Downloading " + path);
int fsa_handle = getClient().get_fsa_handle();
Result<Integer> res = fsa.FSA_OpenFile(fsa_handle, path, "r");
boolean success = false;
byte[] result = null;
if(res.getResultValue() == 0){
int block_size = 0x400;
ByteArrayOutputStream out = new ByteArrayOutputStream();
success = true;
while(true){
Result<byte[]> read_result= fsa.FSA_ReadFile(fsa_handle, res.getData(), 0x1, block_size);
if(read_result.getResultValue() <0){
Logger.logErr("FSA_ReadFile returned " + read_result.getResultValue());
success = false;
break;
}
out.write(Arrays.copyOf(read_result.getData(), read_result.getResultValue()));
if(read_result.getResultValue() <= 0)
break;
}
fsa.FSA_CloseFile(fsa_handle, res.getData());
if(success){
result = out.toByteArray();
}
}
return result;
}
public boolean downloadFile(String sourcePath, String filename, String targetPath) throws IOException {
return downloadFile(sourcePath, filename, targetPath,null);
}
public boolean downloadFile(String sourcePath,String sourceFilename,String targetPath,String targetFileName) throws IOException {
byte[] data = downloadFileToByteArray(sourcePath + "/" + sourceFilename);
if(data == null){
System.out.println("failed");
return false;
}
String subdir = "";
if(targetFileName == null){
subdir += targetPath + "/" + sourceFilename;
}else{
subdir += targetPath + "/" + targetFileName;
}
if(subdir.startsWith("/")){
subdir = subdir.substring(1);
}
//System.out.println(subdir);
Utils.createSubfolder(subdir);
FileOutputStream stream = new FileOutputStream(subdir);
try {
stream.write(data);
} finally {
stream.close();
}
return true;
}
public FSAOperations getFSAOperations() { public FSAOperations getFSAOperations() {
return fsa; return fsa;
} }
public void setFSAOperations(FSAOperations fsa) { public void setFSAOperations(FSAOperations fsa) {
this.fsa = fsa; this.fsa = fsa;
} }
public SystemOperations getSystem() {
return system;
}
public void setSystem(SystemOperations system) {
this.system = system;
}
} }

5
src/de/mas/wupclient/client/utils/MetaInformation.java
View File

@ -1,8 +1,6 @@
package de.mas.wupclient.client.utils; package de.mas.wupclient.client.utils;
import java.io.Serializable; import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
public class MetaInformation implements Comparable<MetaInformation>, Serializable{ public class MetaInformation implements Comparable<MetaInformation>, Serializable{
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -109,9 +107,6 @@ public class MetaInformation implements Comparable<MetaInformation>, Serializabl
@Override @Override
public String toString(){ public String toString(){
String result = getTitleIDAsString() + ";" + region +";" + getContent_platform() + ";" + getCompany_code() + ";"+ getProduct_code()+ ";" + getID6() + ";" + getLongnameEN(); String result = getTitleIDAsString() + ";" + region +";" + getContent_platform() + ";" + getCompany_code() + ";"+ getProduct_code()+ ";" + getID6() + ";" + getLongnameEN();
for(Integer i :versions){
result += ";" + i;
}
return result; return result;
} }

46
src/de/mas/wupclient/client/utils/Utils.java
View File

@ -65,10 +65,7 @@ public class Utils {
} }
public static byte[] intToBigEndianByteArray(int value){ public static byte[] intToBigEndianByteArray(int value){
ByteBuffer destByteBuffer = ByteBuffer.allocate(4); return m_packBE(value);
destByteBuffer.order(ByteOrder.BIG_ENDIAN);
destByteBuffer.putInt(value);
return destByteBuffer.array();
} }
public static int bigEndianByteArrayToInt(byte[] data){ public static int bigEndianByteArrayToInt(byte[] data){
@ -139,7 +136,7 @@ public class Utils {
String company_code = document.getElementsByTagName("company_code").item(0).getTextContent().toString(); String company_code = document.getElementsByTagName("company_code").item(0).getTextContent().toString();
String content_platform = document.getElementsByTagName("content_platform").item(0).getTextContent().toString(); String content_platform = document.getElementsByTagName("content_platform").item(0).getTextContent().toString();
String region = document.getElementsByTagName("region").item(0).getTextContent().toString(); String region = document.getElementsByTagName("region").item(0).getTextContent().toString();
MetaInformation nusinfo = new MetaInformation(Utils.StringToLong(title_id),longname,ID6,proc,content_platform,company_code,(int) StringToLong(region),new String[1]); MetaInformation nusinfo = new MetaInformation(Utils.StringToLong(title_id),longname,ID6,proc,content_platform,company_code,(int) StringToLong(region));
return nusinfo; return nusinfo;
} catch (ParserConfigurationException | SAXException | IOException e) { } catch (ParserConfigurationException | SAXException | IOException e) {
@ -170,4 +167,43 @@ public class Utils {
} }
} }
public static byte[] m_packBE(Object... args){
return m_pack(ByteOrder.BIG_ENDIAN,args);
}
public static byte[] m_pack(ByteOrder order,Object... args){
int totalLength = 0;
for(Object o :args){
if(o instanceof String){
totalLength += ((String)o).getBytes().length;
}else if(o instanceof Integer){
totalLength += 0x04;
}else if(o instanceof int[]){
totalLength += 0x04 * ((int[])o).length;
}else if(o instanceof byte[]){
totalLength += ((byte[])o).length;
}else{
Logger.logErr("Can't use this datatype");
}
}
ByteBuffer destByteBuffer = ByteBuffer.allocate(totalLength);
destByteBuffer.order(order);
for(Object o :args){
if(o instanceof String){
destByteBuffer.put(((String)o).getBytes());
}else if(o instanceof Integer){
destByteBuffer.putInt((Integer)o);
}else if(o instanceof int[]){
for(Integer i : ((int[])o)){
destByteBuffer.putInt(i);
}
}else if(o instanceof byte[]){
destByteBuffer.put((byte[])o);
}else{
Logger.logErr("Can't use this datatype");
}
}
return destByteBuffer.array();
}
} }