Sponsored Links

Sponsored Links

Page 2 of 93 FirstFirst 12341252 ... LastLast
Results 11 to 20 of 926



  1. #11
    Member DAXGr's Avatar
    Join Date
    May 2011
    Posts
    35
    Sponsored Links
    Sponsored Links
    Ps1 emulation capability applies to every known model.

    Sent from my X10mini using Tapatalk.

  2. #12
    Junior Member dayv's Avatar
    Join Date
    Jun 2011
    Posts
    10
    Sponsored Links

    Question

    Sponsored Links
    What is the minimum firmware needed for this. new here, thanks

  3. #13
    Registered User hardie's Avatar
    Join Date
    Nov 2010
    Posts
    4
    Sponsored Links
    Sponsored Links
    looking forward to future progress.

  4. #14
    Member DAXGr's Avatar
    Join Date
    May 2011
    Posts
    35
    Sponsored Links
    Sponsored Links
    dayv umm what do you mean?

    Sent from my X10mini using Tapatalk.

  5. #15
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,431

    JFW DH PS3 Custom Firmware Beta Testing, CFW Update Details

    Following up on their previous update, this weekend DemonHades has announced that JFW DH PS3 Custom Firmware will be undergoing PlayStation 3 Beta testing soon with details below.

    To quote, roughly translated: Hello friends of the Community DHorg, we know the impatience of many to JFW-DH. Though expect to know that the work we are doing is very tiring and among all those who compose the JFW-DH Team want to open the period Beta testers.

    The Requirements:
    • Registered user community with the status DHorg "Friend devil" at DemonHades.org

    Group A Users:
    • Spanish speaking (in Spanish beta)
    • Internet Connection on the PS3 (not PSN)
    • Backward-Console PAL, NTSC FAT
    • Game-Original 3.56 (not dispensable)
    • Console with Firmware 3.41 or less
    • Original game - PS2, PS1, PS3
    • Backup of the above both PS3, PS2, PS1 (PS3 unpatched)
    • Game store NPDRM 3.56 or 3.55 (not PSOne)
    • Backup 3.41 / 355Kmeaw
    • Linux Live CD USB Red Ribbon

    Group B Users:
    • Spanish speaking (in Spanish beta)
    • Internet Connection on the PS3 (not PSN)
    • Console not backwards-PAL, NTSC FAT
    • Game-Original 3.56 (not dispensable)
    • Console with Firmware 3.41 or less
    • Original game - PS2, PS1, PS3
    • Backup of the above both PS3, PS2, PS1 (PS3 unpatched)
    • Game store NPDRM 3.56 or 3.55 (not PSOne)
    • Backup 3.41 / 3.55 Kmeaw
    • Linux Live CD USB Red Ribbon

    Group C Users:
    • User-Spanish speaking (in Spanish beta)
    • Internet Connection on the PS3 (not PSN)
    • Console not backwards-PAL, NTSC Slim
    • Game-Original 3.56 (not dispensable)
    • Console with Firmware 3.41 or less
    • Original game - PS2, PS1, PS3
    • Backup of the above both PS3, PS2, PS1 (PS3 unpatched)
    • Game store NPDRM 3.56 or 355 (not PSOne)
    • Backup 3.41 / 3.55 Kmeaw
    • Linux Live CD USB Red Ribbon

    The beta test shall undertake not to publish the beta, and have a mechanism that anti leaks, this means that not only would find the informer, but you use it the users activate the safety mechanism to make them shiny bricks (Forewarned is a traitor).

    The beta testers inform the organizer of the bugs to be repaired. The testing period will be from 2 weeks to address everything that contains the JFW-DH and so do not leave nothing out.

    The estimated date for the publication of the JFW-DH is October 1, 2011 (after two weeks testing the above)

    1Saludo and never forget to give us a dot if you have google+ account

    JFW DH PS3 Custom Firmware Beta Testing, CFW Update Details

    JFW DH PS3 Custom Firmware Beta Testing, CFW Update Details

    More PlayStation 3 News...

  6. #16
    Contributor doctorwho05's Avatar
    Join Date
    Sep 2010
    Posts
    12
    Quote Originally Posted by dayv View Post
    What is the minimum firmware needed for this. new here, thanks
    Well to jailbreak you need at least 3.41 FW and a USB Dongle, from there the skies the limit (upgrade-downgrade, CFW).

    I hope it helps.
    Quote Originally Posted by DAXGr View Post
    Ps1 emulation capability applies to every known model.

    Sent from my X10mini using Tapatalk.
    People are wondering if their PS1 Eboots they made for PSP will work on CFW.
    Last edited by doctorwho05; 07-31-2011 at 10:01 PM Reason: Automerged Doublepost

  7. #17
    Banned User Baller786's Avatar
    Join Date
    Jul 2011
    Posts
    11
    not long till it gets leaked.

    "The estimated date for the publication of the JFW-DH is October 1, 2011"

    We're probably gonna have 3.80 firmware by then. and 3.60 custom firmware should defo be out by then.

  8. #18
    Forum Moderator PS3 News's Avatar
    Join Date
    Apr 2005
    Posts
    27,431
    Yea, that does seem a ways off if the JFW DH PS3 Custom Firmware Beta testing is 2 weeks... I guess time will tell for sure though.

    Also below is some more details from blipi who is one of the developers working on OpenPStore: ps3crunch.net/forum/threads/353-JFW-?p=3377#post3377
    Hey people. I've just heard you posted this here, and I just said to myself, let's post too. Atm I'm working on OpenPStore, which is part of the JFW. I've been working on it for many many hours, as all devs which are working on JFW, and it is just disgusting to read people saying JFW is a fake.

    I've seen pics of JFW running, not all of its features though, so it's not fake. There is a whole team working hard every day to bring this to you, and I've actually talked to all of them and I do know their work is real. Just for you to know, now it is 2 am where I live, I've been working till now just to have it all ready for the beta test and not to delay it anymore.

    We want to verify everything is working without any problems before releasing it, to avoid things such as bricks or weird bugs. That's why the beta and further release will take so long. So far it is all progressing fine, and I do have proofs of, at least, my work.

    Here I bring you 2 proofs of how hard we are working (OpenPStore).

    1- We had a problem with a pre-made library to read .xml files (mxml), which was solved by manually coding a new .xml parser.

    xml_parser.h : [Register or Login to view links]
    Code:
        //XML PARSER BY BLIPI
        //Feel free to distribute and use it on any plattform and projects
         
        #ifndef XMLPARSER_H
        #define XMLPARSER_H
         
        #include <stdio.h>
        #include <stdlib.h>
        #include <malloc.h>
        #include <string.h>
         
        typedef struct xml_node_attr{
                char *name;
                char *value;
               
                struct xml_node_attr *next;
        }xml_node_attr;
         
        typedef struct xml_node{
                char *name;
                char *value;
                int level;
                long start_pos;
                long end_pos;
                char closed;
         
         
                struct xml_node_attr *attrs;
                struct xml_node *next;
                struct xml_node *last;
                struct xml_node *child;
                struct xml_node *parent;
        }xml_node;
         
        int XML_Open(char *path);
         
        struct xml_node *XML_ParseAll();
        struct xml_node *XML_SearchNodeFrom(char *name, struct xml_node *start);
        struct xml_node *XML_SearchNode(char *name);
        struct xml_node *XML_GetChild(struct xml_node *node);
        struct xml_node *XML_GetNextNode(struct xml_node *node);
         
        struct xml_node_attr *XML_GetNodeAttr(struct xml_node *node, char *name);
        char *XML_GetNodeValue(struct xml_node *node);
         
        void XML_EndParse(char free_tree);
         
        #endif
    xml_parser.c : [Register or Login to view links]
    Code:
        #include "xmlparser.h"
         
         
        // ----- DEFINES ----- //
        #define XML_UNKNOW                     -1
        #define XML_DUNNOHANDLE                -2
        #define XML_OPEN_NODE                   1
        #define XML_CLOSE_NODE                  2
        #define XML_NODE_NAME                   3
        #define XML_SPECIAL_NODE                4
        #define XML_NAME_DELIMITER              5
        #define XML_ATTR_START                  6
        #define XML_ATTR_DELIMITER              7
        #define XML_NODE_END                    8
        #define XML_CLOSE_END_NODE              9
         
         
        // ----- STRUCTS ----- //
        typedef struct xml_reader_{
                char reading_tag;
                char quote_read;
                char node_ending;
         
                int lvl;
         
                long cur_pos;
         
                char read_buffer[1024];
                char name_buffer[1024];
        }xml_reader_;
         
        xml_reader_ xml_reader = {0};
         
        typedef struct ret_{
                int ret;
                char ch;
        }ret_;
         
         
        // ----- PROTOTYPES ----- //
        void XML_FreeList( void );
        struct ret_ XML_GetChar( void );
        struct xml_node *XML_RecursiveSearchNode(char *name, struct xml_node *node);
         
         
        // ----- VARIABLES -----//
        char xml_path[1024];
         
        char *xml_buffer = NULL;
        long xml_size = 0;
         
         
        struct xml_node *main_tree = NULL;
        struct xml_node *current_node = NULL;
         
        // ----- CODE ----- //
         
        //! Abrir el archivo para parsear posteriormente
        //! path: Ruta relativa o hard coded hacia el xml
        //TODO: No guardar en buffer, leer char a char!
        int XML_Open(char *path){
                FILE *fp = fopen(path, "r");
                if(!fp)
                        return -1;
         
                strcpy(xml_path, path);
         
                fseek(fp, 0, SEEK_END);
                xml_size = ftell(fp);
                rewind(fp);
         
                xml_buffer = (char*)malloc(xml_size+1);
                if(!xml_buffer)
                        return -2;
         
                fread(xml_buffer, 1, xml_size, fp);
         
                fclose(fp);
         
                return 0;
        }
         
         
        struct ret_ XML_GetChar(){
                char ch = xml_buffer[xml_reader.cur_pos++];
                struct ret_ ret;
                ret.ch = ch;
         
                if(xml_reader.quote_read == 1 && ch != '"'){
                        ret.ret = XML_NODE_NAME;
                        goto endfunc;
                }
                if(xml_reader.reading_tag == 0){
                        switch(ch){
                                case '<':
                                        xml_reader.reading_tag = 1;
         
                                        if(xml_buffer[xml_reader.cur_pos] == '/'){
                                                xml_reader.node_ending = 1;
                                                ret.ret = XML_NODE_END;
                                        }else{                                 
                                                xml_reader.node_ending = 0;
                                                ret.ret = XML_OPEN_NODE;
                                        }
         
                                        goto endfunc;
                                default:
                                        ret.ret = XML_UNKNOW;
                                        goto endfunc;
                        }
                }else{
                        if((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')){
                                ret.ret = XML_NODE_NAME;
                                goto endfunc;
                        }else{
                                switch(ch){
                                        case '>':              
                                                xml_reader.reading_tag = 0;
                                                if(xml_buffer[xml_reader.cur_pos-2] == '/')
                                                        ret.ret = XML_CLOSE_END_NODE;
                                                else
                                                        ret.ret = XML_CLOSE_NODE;
                                                goto endfunc;
                                        case '?':
                                                ret.ret = XML_SPECIAL_NODE;
                                                goto endfunc;                                  
                                        case ' ':
                                                ret.ret = XML_NAME_DELIMITER;
                                                goto endfunc;          
                                        case '=':
                                                ret.ret = XML_ATTR_START;
                                                goto endfunc;  
                                        case '"':
                                                xml_reader.quote_read = !xml_reader.quote_read;
                                                ret.ret = XML_ATTR_DELIMITER;
                                                goto endfunc;  
                                }
                        }
                }
         
         
        endfunc:
                return ret;
        }
         
        struct xml_node *XML_ParseAll(){
                char action = 0;
                char ignore = 0;
                int buffer_pos = 0;
         
                memset(xml_reader.read_buffer, 0, 1024);
                memset(xml_reader.name_buffer, 0, 1024);
                xml_reader.reading_tag = 0;
                xml_reader.quote_read = 0;
         
                struct xml_node_attr *last_attr = NULL;
                struct xml_node_attr *first_attr = NULL;
         
                while(xml_reader.cur_pos < xml_size){
                        struct ret_ ret = XML_GetChar();
                       
                        if(ignore && ret.ret != XML_SPECIAL_NODE)
                                continue;
         
                        switch(ret.ret){
                                case XML_SPECIAL_NODE:
                                        ignore = !ignore;
                                        break;
                                case XML_OPEN_NODE:
                                       
                                        if(!main_tree){
                                                main_tree = current_node = (struct xml_node*)malloc(sizeof(struct xml_node));                                  
                                                memset(current_node, 0, sizeof(struct xml_node));
                                        }else if(current_node->closed){
                                                current_node->next = (struct xml_node*)malloc(sizeof(struct xml_node));
                                                memset(current_node->next, 0, sizeof(struct xml_node));
                                                current_node->next->parent = current_node->parent;
                                                current_node->next->last = current_node;
                                                current_node = current_node->next;
                                        }else{
                                                current_node->child = (struct xml_node*)malloc(sizeof(struct xml_node));
                                                memset(current_node->child, 0, sizeof(struct xml_node));
                                                current_node->child->parent = current_node;
                                                current_node = current_node->child;
                                        }
         
                                        action = 0;
                                        break;
                                case XML_NODE_NAME:
                                        xml_reader.read_buffer[buffer_pos++] = ret.ch;
                                        break;
                                case XML_NAME_DELIMITER:{
                                        if(buffer_pos > 0){
                                               
                                                if(action == 0)
                                                        strcpy(xml_reader.name_buffer, xml_reader.read_buffer);
         
                                                memset(xml_reader.read_buffer, 0, 1024);
                                                buffer_pos = 0;
         
                                        }
                                }break;
         
                                case XML_ATTR_START:{
                                        struct xml_node_attr *temp_attr = (struct xml_node_attr*)malloc(sizeof(struct xml_node_attr));
                                        memset(temp_attr, 0, sizeof(struct xml_node_attr));
         
                                        temp_attr->name = (char*)malloc(buffer_pos);
                                        strcpy(temp_attr->name, xml_reader.read_buffer);
                                                               
                                        if(last_attr != NULL)
                                                last_attr->next = temp_attr;
                                        last_attr = temp_attr;
         
                                        if(first_attr == NULL)
                                                first_attr = last_attr;
         
                                        memset(xml_reader.read_buffer, 0, 1024);
                                        buffer_pos = 0;
                                }break;
         
                                case XML_ATTR_DELIMITER:
                                        if(xml_reader.quote_read == 0){
         
                                                last_attr->value = (char*)malloc(buffer_pos);
                                                strcpy(last_attr->value, xml_reader.read_buffer);
                                       
                                                memset(xml_reader.read_buffer, 0, 1024);
                                                buffer_pos = 0;
                                        }
                                        break;
         
                                case XML_CLOSE_END_NODE:
                                case XML_CLOSE_NODE:
                                        if(xml_reader.node_ending == 0){
                                                current_node->name = (char*)malloc(buffer_pos);
                                                if(strlen(xml_reader.name_buffer) > 0)
                                                        strcpy(current_node->name, xml_reader.name_buffer);
                                                else
                                                        strcpy(current_node->name, xml_reader.read_buffer);
         
                                                current_node->level = xml_reader.lvl;
                                                current_node->attrs = first_attr;                                                                                      
                                                current_node->start_pos = xml_reader.cur_pos;
                                        }                                      
                                                                                                       
                                        memset(xml_reader.name_buffer, 0, 1024);
                                        memset(xml_reader.read_buffer, 0, 1024);
                                        buffer_pos = 0;
         
                                        first_attr = NULL;
                                        last_attr = NULL;
         
                                        if(ret.ret == XML_CLOSE_END_NODE){
                                                current_node->closed = 1;
                                                current_node->end_pos = xml_reader.cur_pos;
                                        }
         
                                        break;
         
                                case XML_NODE_END:
                                        while(current_node->closed == 1)
                                                current_node = current_node->parent;
         
                                        current_node->closed = 1;
                                        current_node->end_pos = xml_reader.cur_pos;
         
                                        memset(xml_reader.name_buffer, 0, 1024);
                                        memset(xml_reader.read_buffer, 0, 1024);
                                        buffer_pos = 0;
         
                                        break;
         
                                default:
                                        break;
                        }
                }
               
                return main_tree;
        }
         
        struct xml_node *XML_RecursiveSearchNode(char *name, struct xml_node *node){
                if(strcmp(name, node->name) == 0)
                        return node;
         
                struct xml_node *ret = NULL;
         
                if(node->child)
                        ret = XML_RecursiveSearchNode(name, node->child);
         
                if(ret)
                        return ret;
         
                if(node->next)
                        ret = XML_RecursiveSearchNode(name, node->next);
                       
                if(ret)
                        return ret;
         
                return NULL;
        }
         
        struct xml_node *XML_SearchNodeFrom(char *name, struct xml_node *start){
                return XML_RecursiveSearchNode(name, start);
        }
        struct xml_node *XML_SearchNode(char *name){
                return XML_RecursiveSearchNode(name, main_tree);
        }
         
        struct xml_node *XML_GetChild(struct xml_node *node){
                return node->child;
        }
         
        struct xml_node *XML_GetNextNode(struct xml_node *node){
                return node->next;
        }
         
        struct xml_node_attr *XML_GetNodeAttr(struct xml_node *node, char *name){
                struct xml_node_attr *iterator = node->attrs;
                while(iterator != NULL){
                        if(strcmp(iterator->name, name) == 0)
                                return iterator;
                        iterator = iterator->next;
                }
         
                return NULL;
        }
         
        char *XML_GetNodeValue(struct xml_node *node){
                if(node->value == NULL){
                        int len = node->end_pos - node->start_pos - 1;
                        char *buffer =(char*)malloc(len);
                        memcpy(buffer, &xml_buffer[node->start_pos], len);
                        buffer[len] = '\0';
                        node->value = buffer;
                }
                return node->value;
        }
         
        void XML_RecursiveFreeNode(xml_node *node){
                if(node->child)
                        XML_RecursiveFreeNode(node->child);
         
                if(node->next)
                        XML_RecursiveFreeNode(node->next);
         
                free(node);
                node = NULL;
        }
         
        //! Liberar la memoria ocupada por xml_buffer
        void XML_EndParse(char free_tree){
                free(xml_buffer);
         
                if(free_tree)
                        XML_RecursiveFreeNode(main_tree);
         
                main_tree = current_node = NULL;
        }
    (Don't expect to find any OpenPStore here, as it is only a .xml parser)

    2- Final GUI design of OpenPStore (Not a pic of a ps3, but from a PC. Though PS3 is exactly the same):
    It will come in multiple colors, with an autochanger (to random color) feature.


    If you want to I can keep you updated. JFW is real, and we are putting all our effort into it. Do not trust any fake release/leak! I don't know if the brick thing is true, but having seen all the work which has been done here, I would just trust it and not mess around.

    Nobody is going to brick nobody's console unless someone leaks the JFW. And, even if it is leaked, if you don't use the leaked beta, you dont' have to worry about anything. And ofcourse, the final release won't have this anti-leak feature.

    I also have to say thanks to everyone of you who do trust in us and give us support, as support and opinions is our only pay back for the work

    Blipi

    PS: If it was for me, I would translate JFW and it's homebrew to English and more languages, but as I am not the only one who works in this project, I don't know when English support will come or whether it will come or not. Sorry.

    PS2: For those claiming evidence... Beta will be here soon, just wait. You cant trust us or not. I know what I'm doing, and I do know that it is real. I don't even have a ps3 to test OpenPStore too, and I have to keep asking for testers. More than 5 people have already tried OpenPStore, and every one of them could tell you that it is real.
    Attached Images<br><br> Attached Images

    Attached Files Attached Files

  9. #19
    Senior Member shummyr's Avatar
    Join Date
    Sep 2008
    Posts
    739
    This is getting better and better of a firmware.

  10. #20
    Junior Member xragel2478's Avatar
    Join Date
    Jul 2009
    Posts
    14

    Exclamation

    shiny bricks?... really ? why would they purposely brick a console? i understand to weed out traitors, but why not let the beta be optional. another way of owning us like sony does.

 

Sponsored Links

Page 2 of 93 FirstFirst 12341252 ... LastLast

Tags for this Thread

Affiliates - Contact Us - PS3 Downloads - Privacy Statement - Site Rules - Top - © 2014 PlayStation 3 News